diff --git a/README.md b/README.md
index 2a4a4f8..d827745 100644
--- a/README.md
+++ b/README.md
@@ -1,31 +1,128 @@
-# philosophy
+# Important Files
 
-## classes
-- compositional
-- only init manipulates the object
-- no inheretance
-- functions return a clone of the object with primary data object cloned and manipulated
-
-## other
-- heavy inference from type hints
-- library-ize everything
-- thin CLI wrapper as stand alone file
-- pyproject setup only
-- deveopment branch with pyenv to source into shell for development
-- data oriented with classes being simplest data conainers with helper functions
-
-## imports
-Files with an _prefix_ underscore are, by convention, imported in `__init__.py`. For example,
-
-```python
-from ._rgb_ import *
+```
+├── bashrc_defl.sh              |
+├── bin                         |
+│   ├── ddwatch.sh              |
+│   └── deflMergeDevToMain.sh   |
+├── defl                        |
+│   ├── *_.py                   |
+│   ├── _*_.py                  |
+│   ├── _path/                  |
+│   └── thirdParty/             |
+│       └── *                   |
+├── LICENSE.GPL                 |
+├── pyproject.toml              |
+├── README.md                   |
+├── scripts/                    |
+│   └── setup.sh                |
+└── tests/                      |
+    └── test_*.py               |
 ```
 
-This will import all of the functions from `_rgb_` into the module’s name space. So If `_rgb_` contains a function `interpolatePoint` you can reference it by `PythonModuleDemo._rgb_.interpolatePoint` or more simply `PythonModuleDemo.interpolatePoint`. Since this module is intended to provide a swath of functionality I wanted to provide the user with the simplest method of access.
+<!-- ######################################################  -->
 
-The reason all files end with a _suffix_ underscore is to avoid any name collisions with python standard Library. For instance I have a file called `_math_.py`. If it were only called `math.py` it would collide with python standard Library when doing `import math`.
+# Pragdim
+
+-   Data oriented with classes being simplest data conainers with helper functions
+
+## security
+
+-   Minimal use of PyPi dependencies to reduce security overhead
+    -   [Ultralytics AI Library Hacked via GitHub for Cryptomining](https://www.wiz.io/blog/ultralytics-ai-library-hacked-via-github-for-cryptomining)
+-   Use system tools installed via systempackage manager
+    -   Safer but nothing is perfect
+        -   [Backdoor in XZ Utils allows RCE: everything you need to know](https://www.wiz.io/blog/cve-2024-3094-critical-rce-vulnerability-found-in-xz-utils)
+-   `Docker`
+-   `netns` network namespace isolation
+-   When installing packges go to github page and look for an explicit `pip install ...` to avoid typosquatting due to typos.
+-   Don't trust PyPi
+    -   "`Starjacking` is linking a PyPi package to an unrelated repository on GitHub that has plenty of stars, suggesting popularity. [...] there is no validation of these links on PyPi [...]." ([source](https://devclass.com/2023/10/13/pypi-repo-attack-typesquatting-starjacking-and-hidden-code-aims-to-pinch-credentials-and-secrets/))
+
+## Classes
+
+-   Dataclass with functional programming
+
+### Compositional
+
+### No Inheritance
+
+-   Limited use of mixins.
+-   No super classing.
+-   The inheritence hierarcy is a single level.
+-   No object has a parent.
+-   https://doc.rust-lang.org/book/ch18-01-what-is-oo.html
+    -   ```
+        Inheritance has recently fallen out of favor as a programming design solution in many programming languages
+        because it’s often at risk of sharing more code than necessary. Subclasses shouldn’t always share all
+        characteristics of their parent class but will do so with inheritance. This can make a program’s design less
+        flexible. It also introduces the possibility of calling methods on subclasses that don’t make sense or that
+        cause errors because the methods don’t apply to the subclass. In addition, some languages will only allow
+        single inheritance (meaning a subclass can only inherit from one class), further restricting the flexibility
+        of a program’s design.
+        ```
+
+### Manipulation
+
+-   Dot Chaining
+    -   Most functions return `self` so many functions can run on one line.
+    -   See `Run()` class.
+    -   Example: `Run(['ls']).run(out=F, err=T).assSuc().json()`
+        -   `Run(['ls'])` creates the object
+        -   `.run(out=F, err=T).assSuc()` both return `self`
+        -   `.json()` returns a dict
+-   `clone()` function returns a copy of the object with primary data object duplicated and altered
+    -   see `Dath()` class.
+-   `set`/`get`
+    -   See `Find()` class.
+
+### Type Hints
+
+-   inference
+
+## Module
+
+### library-ize everything
+
+-   Thin CLI wrapper as stand alone file
+
+### Setup
+
+-   `scripts/setup.sh`
+
+### pyproject.toml
+
+### Files
+
+-   Always use underscore to avoid namespace collision
+    -   Example:
+        -   `import math` is a python stdlib module.
+        -   If a file, `math.py`, exists in the source directory it will cause collision.
+        -   Instead create `math_.py` to subvert the issue.
+-   `_*_.py` (i.e. `_path_.py`)
+    -   This is always import and casted into the modules namespace.
+    -   Imported in `__init__.py`
+    -   Example:
+        -   there is a Class called `Dath` in `src/defl/_path_.py`
+        -   You can refer to it using `from dath._path_ import Dath` or simply `from defl import Dath`
+-   `*_.py` (i.e. `_path_.py`)
+    -   These are not automatically imported.
+    -   One must import them explicitly.
+    -   Example:
+        -   `from dath.mpv2_ import Mpv`
+
+## Branching
+
+-   Deveopment branch with env to source into shell for development
+-   `defl`/`deflDev`
+-   `bin/deflMergeDevToMain.sh`
+
+## Unit Tests
+
+<!-- ######################################################  -->
+
+# Import Time
 
-# import time
 ```bash
 λ timeRepeat.py - -c 500 -- python -c ''
 0.021840
diff --git a/alias.toml b/alias.toml
new file mode 100644
index 0000000..f0e23aa
--- /dev/null
+++ b/alias.toml
@@ -0,0 +1,4 @@
+
+[deflWhich]
+allowDuplicate = true
+cmd            = "python  -c 'import defl;print(defl.Dath(defl.__file__).gitRepoRoot())'"
diff --git a/defl/_argsFromObject2_.py b/defl/_argsFromObject2_.py
index ec2236e..3f99735 100644
--- a/defl/_argsFromObject2_.py
+++ b/defl/_argsFromObject2_.py
@@ -19,6 +19,8 @@ from ._typeCheck_ import *
 from rich import panel
 from rich.table import Table
 
+from enum import Enum
+
 
 from pydantic import create_model, ConfigDict
 
@@ -42,6 +44,10 @@ class SublimationError(ArgFromObjError):
     __slot__ = ()
 
 
+class ReifyError(ArgFromObjError):
+    __slot__ = ()
+
+
 class CliError(ArgFromObjError):
     __slot__ = ()
 
@@ -92,7 +98,19 @@ class _Flag:
                     _._corporealization = _.default
             # print('bool', _)
         else:
-            _._corporealization = tc.dominent()(val)
+            dom = tc.dominent()
+            if hasattr(dom, '_value2member_map_'):
+                # print(type(dom), dom, val)
+                val = val.lower()
+                match = [v for k, v in dom._value2member_map_.items() if k.lower() == val]
+                if len(match) == 0:
+                    raise ReifyError(f'{dom} has no value {val}')
+                elif len(match) > 1:
+                    raise ReifyError(f'{dom} has multiple values for {val} {match}')
+                match = match[0]
+                _._corporealization = dom(match)
+            else:
+                _._corporealization = dom(val)
         return _
 
     def sublimate(_) -> N:  # | finalize the type
diff --git a/defl/_basic_.py b/defl/_basic_.py
index 2add766..bd1adf5 100644
--- a/defl/_basic_.py
+++ b/defl/_basic_.py
@@ -441,7 +441,9 @@ def dictFromListOfList(theList):
 
 class Enumer(enum.StrEnum):
     # def __init__(_, *args, **kargs) -> N:
-    #     raise ValueError('Dont initialize')
+    #     print('__init__', args, kargs)
+    # raise ValueError('Dont initialize')
+
     # print(args)
     # super().__init__(*args, **kargs)
 
@@ -453,6 +455,20 @@ class Enumer(enum.StrEnum):
             if keyStr.lower() == x.lower() or valObj is x:
                 return valObj
 
+    # def __call__(_, *args, **kargs):
+    #     print('__call__', args, kargs)
+    #     return super().__call__(_, *args, **kargs)
+
+    # def __new__(cls, value):
+    #     # https://docs.python.org/3/library/enum.html#enum.Enum.__new__
+    #     # | When writing a custom __new__, do not use super().__new__ – call the appropriate __new__ instead.
+    #     # |     ...This is why inheritance sucks...
+    #     print('__new__', cls, value)
+    #     obj = str.__new__(cls)
+    #     obj._value_ = value
+    #     # obj = cls.__new__(cls, value)
+    #     # print(obj)
+
     # def __getattr__(*args, **kargs):
     #     print(args, kargs)
 
@@ -489,3 +505,21 @@ def roundRobin(*iterables):
 def takeCount(count, iterab):
     for i, x in itertools.takewhile(lambda x: x[0] < count, zip(itertools.count(), iterab)):
         yield x
+
+
+K = TypeVar('K')
+V = TypeVar('V')
+
+
+def resolveKeyValToVal(
+    includeMap: Mapping[K, V],
+    include: Iterable[K | V],
+    defaultIncludeAll: bool = F,
+) -> list[V]:
+    if defaultIncludeAll and not include:
+        return list(includeMap.values())
+    includeList = []
+    for k, v in includeMap.items():
+        if k in include or v in include:
+            includeList.append(v)
+    return includeList
diff --git a/defl/_jq_.py b/defl/_jq_.py
index 7ede4a5..dcf9b5f 100644
--- a/defl/_jq_.py
+++ b/defl/_jq_.py
@@ -7,6 +7,7 @@ from subprocess import Popen, PIPE
 from dataclasses import dataclass
 from typing import Any, Callable, Mapping, NewType
 
+from typing import BinaryIO
 from json.decoder import JSONDecodeError
 from .thirdParty import jstyleson
 from ._typing_ import *
@@ -138,7 +139,7 @@ def jdumps(
         res, __ = sp.communicate(res.encode('utf8'))
         res = bytearray(res)
         for frm, to in jqColPost.items():
-            res = res.replace(frm, to)  # for key name
+            res = res.replace(frm, to)  # | for key name
         if asBytes:
             res = res.strip(b'\n')
         else:
@@ -199,10 +200,10 @@ def jloads(text, *args, **kargs):
     return jstyleson.loads(text, *args, **kargs)
 
 
-def jdump(data, output: io.BytesIO = N) -> io.BytesIO:
+def jdump(data, output: io.BytesIO = N, **kargs) -> io.BytesIO:
     if output is N:
         output = io.BytesIO()
-    json.dump(obj=jsonReprDump(data), fp=output)
+    json.dump(obj=jsonReprDump(data), fp=output, **kargs)
     return output
 
 
@@ -269,6 +270,10 @@ class JqLoad:
             yield from _.fromFile(src=fp)
 
 
+class JqDumpInputDiedError(Exception):
+    __slot__ = ()
+
+
 @dataclass(slots=T, kw_only=T, frozen=F)
 class JqDump:
     "line oriented json save"
@@ -276,34 +281,40 @@ class JqDump:
     # TODO JqOptions
     # | defl.JqDump(output=Path('file').open('ab', buffering=0))
 
-    output: io.BytesIO = field(kw_only=F, repr=T)
+    output: TextIO = field(kw_only=F, repr=T)
     trans: str = '.'
+    append: bool = F
     _run: Popen = N
 
     def __post_init__(_):
-        pass
-
+        # TODO should use https://docs.python.org/3/library/io.html#io.TextIOWrapper ? write_through=True?
         if hasattr(_.output, 'open'):
-            _.output = _.output.open('wb')
+            _.output = _.output.open('a' if _.append else 'w', buffering=1)
+
+        assert 'b' not in _.output.mode  # | can not use byte mode due to line_buffering
+        assert hasattr(_.output, 'fileno')
 
         com = ['jq', '--compact-output', '--monochrome-output', '--unbuffered', _.trans]
-        _._run = Popen(com, stdout=_.output, stdin=PIPE, stderr=PIPE, bufsize=0)
+        _._run = Popen(com, stdout=_.output, stdin=PIPE, stderr=PIPE, bufsize=1, encoding='utf8')
 
     def dump(_, item: Any) -> N:
-        # TODO avoice json.dumps leading a string and encode. direct to bytes
-        a = json.dumps(jsonReprDump(item)).encode()
+        a = json.dumps(jsonReprDump(item))
         _._run.stdin.write(a)
+        _._run.stdin.write('\n')  # | required for line_buffering to instantly write to file
+        # | If line_buffering is True, flush() is implied when a call to write contains a newline character or a carriage return.
         _._run.stdin.flush()
-        # TODO not flushing to file immediatly?
+        if _._run.poll() is not N:
+            raise JqDumpInputDiedError()
         _.output.flush()
         return _
 
     def done(_) -> Generator[dict, N, N]:
         _._run.stdin.close()
         _._run.wait()
+        _.output.close()
         if _._run.poll() != 0:
             rc = _._run.poll()
-            msg = [x for x in _._run.stderr.read().decode().split('\n') if x]
+            msg = [x for x in _._run.stderr.read().split('\n') if x]
             raise JqError(f'(rc={rc}) {msg}')
         return _
 
diff --git a/defl/_logger_.py b/defl/_logger_.py
index 7c21202..33e529e 100644
--- a/defl/_logger_.py
+++ b/defl/_logger_.py
@@ -278,8 +278,8 @@ log = Logger()
 log.setLevel(lvl=None, tgtMap=sys.stderr)
 
 
-def depricateWarning(*args):
+def depricateWarning(*args, frameBack=1):
     import inspect
 
     funcName = inspect.currentframe().f_back.f_code.co_name
-    log.warning('Deprication warning', funcName, *args, lineInfo=True, frameBackBefore=1)
+    log.warning('Deprication warning', funcName, *args, lineInfo=True, frameBackBefore=1 + frameBack)
diff --git a/defl/_math_.py b/defl/_math_.py
index 8360741..f499de6 100644
--- a/defl/_math_.py
+++ b/defl/_math_.py
@@ -152,52 +152,6 @@ class BaseNumberSystemMaker:
         return tot
 
 
-@dataclass(slots=T, kw_only=T, frozen=F)
-class UnitFormat:
-    units: dict[str, int | float]
-    fmt: Callable | N = N
-
-    def human(_, mag: int | float) -> tuple[str]:
-        names = tuple(_.units.keys())
-        conv = tuple(_.units.values())
-        i = 0
-        while i + 1 < len(conv) and (nxt := mag / conv[i]) > 1:
-            i += 1
-            mag = nxt
-        if _.fmt:
-            return _.fmt(mag, names[i])
-        return (mag, names[i])
-
-
-ByteUnitFormat = partial(UnitFormat, units={'B': 1024, 'K': 1024, 'M': 1024, 'G': 1024, 'T': 1024, 'P': 1024})
-ByteUnitFormatColor = partial(
-    UnitFormat,
-    units={
-        '[green]B[/green]': 1024,
-        '[magenta]K[/magenta]': 1024,
-        '[yellow]M[/yellow]': 1024,
-        '[orange]G[/orange]': 1024,
-        '[red]T[/red]': 1024,
-        '[white]P[/white]': 1024,
-    },
-)
-
-ThousandsUnitFormat = partial(
-    UnitFormat, units={'': 1000, 'e^1': 1000, 'e^2': 1000, 'e^3': 1000, 'e^4': 1000, 'e^5': 1000}
-)
-ThousandsUnitFormatColor = partial(
-    UnitFormat,
-    units={
-        '[green][/green]': 1000,
-        '[magenta]e^1[/magenta]': 1000,
-        '[yellow]e^2[/yellow]': 1000,
-        '[orange]e^3[/orange]': 1000,
-        '[red]e^4[/red]': 1000,
-        '[white]e^5[/white]': 1000,
-    },
-)
-
-
 def ranges(gap: int, start: int = 0) -> Generator:
     i = start
     while T:
diff --git a/defl/_networking_.py b/defl/_networking_.py
index e3a49f8..f649f68 100644
--- a/defl/_networking_.py
+++ b/defl/_networking_.py
@@ -1,4 +1,4 @@
-import atexit
+import atexit, re
 from ipaddress import IPv4Address
 import ipaddress
 import json
@@ -16,10 +16,11 @@ from ._string_ import randomString
 from ._except_ import tryWrap
 
 from ._typing_ import *
-from ._typing_ import T, N
+from ._typing_ import T, N, F
 from ._rich_ import *
 
 from ipaddress import IPv4Address
+from urllib.parse import urlparse, ParseResult
 
 regIpAddr = r'\b[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+\b'
 regIpAddrComp = re.compile(regIpAddr)
@@ -154,8 +155,8 @@ def downloadFile(url: str, out: Path, progressStr: str = None):
     response = requests.get(url, stream=True)
     size = int(response.headers.get('content-length', 0))
     gotten = 0
-    deleteOnFile = lambda: out.rm(notExistOk=True)
-    atexit.register(deleteOnFile)
+    deleteOnFail = lambda: out.rm(notExistOk=True)
+    atexit.register(deleteOnFail)
     with response as r:
         r.raise_for_status()
         with out.open('wb') as fp:
@@ -165,11 +166,13 @@ def downloadFile(url: str, out: Path, progressStr: str = None):
                     gotten += len(chunk)
                     log.info(
                         f'{progressStr}',
-                        f'{cl.yel}{gotten/1024/1024:,.2f}M{cl.r} / {cl.cyn}{size/1024/1024:,.2f}M{cl.r}',
+                        f'{cl.yel}{gotten/1024/1024:,.2f}M{cl.r}',
+                        '/',
+                        f'{cl.cyn}{size/1024/1024:,.2f}M{cl.r}',
                         end='',
                     )
     log.info(cl.res + cl.startOfLine, end='')
-    atexit.unregister(deleteOnFile)
+    atexit.unregister(deleteOnFail)
 
 
 def dig(
@@ -285,3 +288,85 @@ def pingWait(sendEnv: str | N, sendTo: str, interval: int = 1, waitTime: float =
 #             run.kill('hup')
 #             run.wait()
 #     return Time() - now
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class Url:
+    # todo quoting/dequoting https://docs.python.org/3/library/urllib.parse.html#urllib.parse.quote
+    parseResult: ParseResult = field(kw_only=T, repr=F)
+
+    def __repr__(_) -> str:
+        items = ['scheme', 'netloc', 'path', 'query', 'params', 'fragment']
+        items = {k: getattr(_.parseResult, k) for k in items}
+        items = {k: v for k, v in items.items() if v}
+        return ''.join([f'{_.__class__}', '(', ', '.join([f'{k}={v}' for k, v in items.items() if v]), ')'])
+
+    @classmethod
+    def From(cls, url: str | ParseResult) -> Self:
+        if not inst(url, ParseResult):
+            url = urlparse(url)
+        newNetLoc = re.compile(r'^www\.', flags=re.I).sub('', url.netloc.lower())
+        url = url._replace(netloc=newNetLoc)
+        return cls(parseResult=url)
+
+    @property
+    def s(_) -> str:
+        return _.__str__()
+
+    @property
+    def string(_) -> str:
+        return _.__str__()
+
+    @property
+    def url(_) -> str:
+        return _.__str__()
+
+    def __str__(_) -> str:
+        return _.parseResult.geturl()
+
+    def clean(
+        _,
+        scheme: bool | str = T,
+        netloc: bool | str = T,
+        path: bool | str = T,
+        query: bool | str = T,
+        params: bool | str = F,
+        fragment: bool | str = F,
+    ) -> Self:
+        if scheme is not T:
+            _.parseResult._replace(scheme='' if scheme is F else scheme)
+        if netloc is not T:
+            _.parseResult._replace(netloc='' if netloc is F else netloc)
+        if path is not T:
+            _.parseResult._replace(path='' if path is F else path)
+        if query is not T:
+            _.parseResult._replace(query='' if query is F else query)
+        if params is not T:
+            _.parseResult._replace(params='' if params is F else params)
+        if fragment is not T:
+            _.parseResult._replace(fragment='' if fragment is F else fragment)
+        return _
+
+    @property
+    def scheme(_) -> str:
+        return _.parseResult.scheme
+
+    @property
+    def netloc(_) -> str:
+        return _.parseResult.netloc
+
+    @property
+    def path(_) -> str:
+        return _.parseResult.path
+
+    @property
+    def query(_) -> str:
+        return _.parseResult.query
+
+    @property
+    def params(_) -> str:
+        return _.parseResult.params
+
+    @property
+    def fragment(_) -> str:
+        return _.parseResult.fragment
diff --git a/defl/_path/__init__.py b/defl/_path/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/defl/_path/_assertions_.py b/defl/_path/_assertions_.py
new file mode 100644
index 0000000..20edddc
--- /dev/null
+++ b/defl/_path/_assertions_.py
@@ -0,0 +1,80 @@
+import itertools
+import json, hashlib
+import os
+import pathlib
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+from .._typing_ import *
+from .._except_ import *
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+class _DathAssertions:
+    def assertExists(_) -> Self:
+        if not _.exists():
+            raise DathNotExistsError()
+        return _
+
+    def assertIsAbsolute(_) -> Self:
+        if not _.isAbsolute():
+            raise DathNotIsAbsoluteError()
+        return _
+
+    def assertIsBlockDevice(_) -> Self:
+        if not _.isBlockDevice():
+            raise DathNotIsBlockDeviceError()
+        return _
+
+    def assertIsCharDevice(_) -> Self:
+        if not _.isCharDevice():
+            raise DathNotIsCharDeviceError()
+        return _
+
+    def assertIsDir(_) -> Self:
+        if not _.isDir():
+            raise DathNotIsDirError()
+        return _
+
+    def assertIsFifo(_) -> Self:
+        if not _.isFifo():
+            raise DathNotIsFifoError()
+        return _
+
+    def assertIsFile(_) -> Self:
+        if not _.isFile():
+            raise DathNotIsFileError()
+        return _
+
+    def assertIsMount(_) -> Self:
+        if not _.isMount():
+            raise DathNotIsMountError()
+        return _
+
+    def assertIsRelativeTo(_) -> Self:
+        if not _.isRelativeTo():
+            raise DathNotIsRelativeToError()
+        return _
+
+    def assertIsReserved(_) -> Self:
+        if not _.isReserved():
+            raise DathNotIsReservedError()
+        return _
+
+    def assertIsSocket(_) -> Self:
+        if not _.isSocket():
+            raise DathNotIsSocketError()
+        return _
+
+    def assertIsSymlink(_) -> Self:
+        if not _.isSymlink():
+            raise DathNotIsSymlinkError()
+        return _
diff --git a/defl/_path/_depricated_.py b/defl/_path/_depricated_.py
new file mode 100644
index 0000000..b4582e7
--- /dev/null
+++ b/defl/_path/_depricated_.py
@@ -0,0 +1,142 @@
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+
+import itertools
+import json, hashlib
+import os
+import pathlib
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+
+from ..thirdParty import jstyleson
+from .._microlang_ import MicroLang
+from .._ansii_ import cl
+from .._basic_ import listFromArgsStar
+from .._logger_ import depricateWarning
+from .._typing_ import *
+from .._string_ import randomString
+from .._time_ import Time
+from .._jq_ import jloads, JqLoad, JqDump, jdump
+from .._shell_ import expandEnvVar
+# from ._except_ import *
+# from ._pathChown_ import *
+# from ._pathFilter_ import *
+# from ._pathStatic_ import staticPath, sp, StaticPath
+# from ._pathPathlib_ import _DathPathlib
+# from ._pathTemp_ import _PathTemp
+
+
+def _PathPatch(Dath: Type):
+    # == patch onto Dath
+    # | patch onto Dath to avoid IDE auto resolution
+    def _tempFile(  #!depricate
+        _,  #!depricate
+        autoRemove: bool = T,  #!depricate
+        create: bool = T,  #!depricate
+        fmt: str = '{d}_{r}',  #!depricate
+        direct: bool = F,  #!depricate
+    ) -> Dath:  #!depricate
+        "#!depricate"
+        depricateWarning()
+        p = N  #!depricate
+        while p is none or p.exists():  #!depricate
+            d = Time(fmt='%Y-%m-%d_%H-%M-%S-%f').toStr()  #!depricate
+            r = randomString(10)  #!depricate
+            p = _._path / fmt.format(d=d, r=r)  #!depricate
+        p = Dath(p)  #!depricate
+        if autoRemove:  #!depricate
+            p.addOnDelFunc(partial(p.remove, recursive=T))  #!depricate
+        if create:  #!depricate
+            if direct:  #!depricate
+                p.makeDir()  #!depricate
+            else:  #!depricate
+                p.createFile()  #!depricate
+        return p  #!depricate
+
+    Dath.tmp = _tempFile  #!depricate
+    Dath.tempFile = _tempFile  #!depricate
+    Dath.temp = _tempFile
+
+    def _appendText(_, data: Any, **kargs) -> Self:
+        "#!depricated"
+        if inst(data, bytes | bytearray):  #!depricate
+            mode = 'ab'  #!depricate
+        else:  #!depricate
+            mode = 'a'  #!depricate
+            data = str(data)  #!depricate
+        with _._path.open(mode, **kargs) as fp:  #!depricate
+            fp.write(data)  #!depricate
+            fp.flush()
+        return _  #!depricate
+
+    Dath.appendText = _appendText  #!depricate
+
+    def _appendLine(_, data: Any, **kargs):  #!depricate
+        "#!depricated"
+        _.appendText(f'{data}\n', **kargs)  #!depricate
+
+    Dath.appendLine = _appendLine  #!depricate
+
+    def _Temp(cls):  #!depricate
+        tmp = Dath('~/tmp/').makeDir()  #!depricate
+        return tmp  #!depricate
+
+    Dath.Temp = classmethod(_Temp)
+
+    #!depricate
+    def _Shm(cls):  #!depricate
+        user = os.environ['USER']  #!depricate
+        tmp = Dath(f'/dev/shm/{user}').makeDir()  #!depricate
+        return tmp  #!depricate
+
+    Dath.Shm = classmethod(_Shm)
+
+    #!depricate
+    def _FromEnv(cls, var: str, orElse: str | N = N):  #!depricate
+        return cls(os.environ.get(var, orElse))  #!depricate
+
+    Dath.FromEnv = classmethod(_FromEnv)
+
+    Dath.jsonc = Dath.loadJsonc  # TODO depricate
+    Dath.json = Dath.loadJson  # TODO depricate
+    Dath.toml = Dath.loadToml  # TODO depricate
diff --git a/defl/_path/_except_.py b/defl/_path/_except_.py
new file mode 100644
index 0000000..ac5816b
--- /dev/null
+++ b/defl/_path/_except_.py
@@ -0,0 +1,85 @@
+from .._typing_ import *
+
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+class DathValueError(Exception):
+    __slot__ = ()
+
+
+class DathNotInitableError(Exception):
+    __slot__ = ()
+
+
+class DathNotExistsError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsAbsoluteError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsBlockDeviceError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsCharDeviceError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsDirError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsFifoError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsFileError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsMountError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsRelativeToError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsReservedError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsSocketError(Exception):
+    __slot__ = ()
+
+
+class DathNotIsSymlinkError(Exception):
+    __slot__ = ()
+
+
+class DathValueError(Exception):
+    __slot__ = ()
+
+
+__all__ = (
+    'DathValueError',
+    'DathNotInitableError',
+    'DathNotExistsError',
+    'DathNotIsAbsoluteError',
+    'DathNotIsBlockDeviceError',
+    'DathNotIsCharDeviceError',
+    'DathNotIsDirError',
+    'DathNotIsFifoError',
+    'DathNotIsFileError',
+    'DathNotIsMountError',
+    'DathNotIsRelativeToError',
+    'DathNotIsReservedError',
+    'DathNotIsSocketError',
+    'DathNotIsSymlinkError',
+    'DathValueError',
+)
diff --git a/defl/_path/_filter_.py b/defl/_path/_filter_.py
new file mode 100644
index 0000000..f58adc0
--- /dev/null
+++ b/defl/_path/_filter_.py
@@ -0,0 +1,76 @@
+import itertools
+import json, hashlib
+import os
+import pathlib
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+from .._typing_ import *
+from .._microlang_ import MicroLang
+from .._except_ import *
+
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class PathFilter:
+    # TODO -mount Don't descend directories on  other  filesystems.
+    file: bool = F
+    blockDevice: bool = F
+    charDevice: bool = F
+    dir: bool = F
+    fifo: bool = F
+    mount: bool = F
+    reserved: bool = F
+    socket: bool = F
+    link: bool = F
+    test: MicroLang | Iterable | none = N
+
+    def __post_init__(_):
+        if not (_.file or _.blockDevice or _.charDevice or _.dir or _.fifo or _.mount or _.reserved or _.socket):
+            _.file = T
+            _.blockDevice = T
+            _.charDevice = T
+            _.dir = T
+            _.fifo = T
+            _.mount = T
+            _.reserved = T
+            _.socket = T
+        if _.test and not isinstance(_.test, MicroLang):
+            _.test = MicroLang(_.test)
+
+    def match(_, path: _Dath | pathlib.Path | str):
+        if isinstance(path, str):
+            path = _.__class__(path)
+        return (
+            (
+                (_.file and path.is_file())
+                or (_.dir and path.is_dir())
+                or (_.blockDevice and path.is_block_device())
+                or (_.charDevice and path.is_char_device())
+                or (_.fifo and path.is_fifo())
+                or (_.mount and path.is_mount())
+                or (_.reserved and path.is_reserved())
+                or (_.socket and path.is_socket())
+            )
+            and ((not _.link and not path.is_symlink()) or (_.link and path.is_symlink()))
+            and (not _.test or _.test.eval(path))
+        )
+
+    def filterMany(_, *paths: Iterable, glob: str = N) -> dict:
+        paths = listFromArgsStar(*paths)
+        for x in paths:
+            if glob:
+                for y in x.glob(glob):
+                    if _.match(y):
+                        yield y
+            elif _.match(x):
+                yield x
diff --git a/defl/_path/_metaData_.py b/defl/_path/_metaData_.py
new file mode 100644
index 0000000..b895185
--- /dev/null
+++ b/defl/_path/_metaData_.py
@@ -0,0 +1,37 @@
+import itertools
+import json, hashlib
+import os
+import pathlib
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+from .._typing_ import *
+from .._except_ import *
+from .._basic_ import DotDict
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+# TODO stat
+class _DathMetaData:
+    def ffprobe(_):
+        from .._run_ import Run
+
+        cmd = ['ffprobe', '-v', 'quiet', '-show_streams', '-print_format', 'json', '-show_format', _]
+        return DotDict(Run(cmd).log().run(T, T).assSuc().json())
+
+    def exiftool(_):
+        from .._run_ import Run
+
+        cmd = ['/usr/bin/vendor_perl/exiftool', '-j', _]
+        res = Run(cmd).log().run(T, T).assSuc().json()
+        assert len(res) == 1
+        res = DotDict(res[0])
+        return res
diff --git a/defl/_path/_pathlib_.py b/defl/_path/_pathlib_.py
new file mode 100644
index 0000000..a078713
--- /dev/null
+++ b/defl/_path/_pathlib_.py
@@ -0,0 +1,357 @@
+import itertools
+import json, hashlib
+import os
+import pathlib
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+from .._typing_ import *
+from .._except_ import *
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+class _DathPathlib:
+    # == pathlib.Path properties
+    @property
+    def parts(_) -> List[str]:
+        return _._path.parts
+
+    @property
+    def drive(_) -> str:
+        """
+        Path('/a/b/c.d.e.f').drive => ''
+        Path('a/b/c.d.e.f').drive => ''
+        """
+        return _._path.drive
+
+    @property
+    def root(_) -> str:
+        """
+        Path('/a/b/c.d.e.f').root => '/'
+        Path('a/b/c.d.e.f').root => ''
+        """
+        return _._path.root
+
+    @property
+    def anchor(_) -> str:
+        """
+        Path('/a/b/c.d.e.f').anchor => '/'
+        Path('a/b/c.d.e.f').anchor => ''
+        """
+        return _._path.anchor
+
+    @property
+    def parents(_):  # -> Generator[_Dath]:
+        """
+        Path('/a/b/c.d.e.f').parents => <PosixPath.parents>
+        Path('a/b/c.d.e.f').parents => <PosixPath.parents>
+        [x for x in _Dath('a/b/c.d.e.f').parents] => [PosixPath('a/b'), PosixPath('a'), PosixPath('.')]
+        """
+        for i in _._path.parents:
+            yield _.__class__(i)
+
+    @property
+    def parent(_) -> _Dath:
+        """
+        Path('/a/b/c.d.e.f').parent => Path('/a/b')
+        Path('a/b/c.d.e.f').parent => Path('a/b')
+        """
+        return _.__class__(_._path.parent)
+
+    @property
+    def name(_) -> str:
+        """
+        Path('/a/b/c.d.e.f').name => 'c.d.e.f'
+        Path('a/b/c.d.e.f').name => 'c.d.e.f'
+        """
+        return _._path.name
+
+    @property
+    def suffix(_) -> str:  # | extension
+        """
+        _Dath('/a/b/c.d.e.f').suffix => '.f'
+        _Dath('a/b/c.d.e.f').suffix => '.f'
+        """
+        return _._path.suffix
+
+    @property
+    def suffixes(_) -> list:
+        """
+        Path('/a/b/c.d.e.f').suffixes => ['.d', '.e', '.f']
+        Path('a/b/c.d.e.f').suffixes => ['.d', '.e', '.f']
+        """
+        return _._path.suffixes
+
+    @property
+    def suffixesStr(_) -> list:
+        """
+        Path('/a/b/c.d.e.f').suffixes => '.d.e.f']
+        Path('a/b/c.d.e.f').suffixes => '.d.e.f']
+        """
+        return ''.join(_.suffixes)
+
+    @property
+    def stem(_) -> str:
+        """
+        Path('/a/b/c.d.e.f').stem => 'c.d.e'
+        Path('a/b/c.d.e.f').stem => 'c.d.e'
+        """
+        return _._path.stem
+
+    @property
+    def stemBase(_) -> str:
+        # not part of pathlib
+        """
+        Path('/a/b/c.d.e.f').stem => 'c'
+        Path('a/b/c.d.e.f').stem => 'c'
+        """
+        return re.sub(r'\..*', '', _._path.name)
+
+    # == pathlib.Path functions
+
+    def absolute(_):
+        return _.castToPath(_._path.absolute())
+
+    def as_posix(_):
+        return _.castToPath(_._path.as_posix())
+
+    def as_uri(_):
+        return _.castToPath(_._path.as_uri())
+
+    def chmod(_, mode, *, follow_symlinks=T):
+        return _.castToPath(_._path.chmod(mode, follow_symlinks=follow_symlinks))
+
+    def stat(_, *, follow_symlinks=T):
+        return _._path.stat(follow_symlinks=follow_symlinks)
+
+    def exists(_) -> bool:
+        return _._path.exists()
+
+    def expanduser(_):
+        return _.castToPath(_._path.expanduser())
+
+    def glob(_, pattern):
+        for i in _._path.glob(pattern):
+            yield _.castToPath(i)
+
+    def group(_):
+        return _.castToPath(_._path.group())
+
+    def hardlink_to(_, target):
+        return _.castToPath(_._path.hardlink_to(target))
+
+    def is_absolute(_) -> bool:
+        return _._path.is_absolute()
+
+    def is_block_device(_) -> bool:
+        return _._path.is_block_device()
+
+    def is_char_device(_) -> bool:
+        return _._path.is_char_device()
+
+    def is_dir(_) -> bool:
+        return _._path.is_dir()
+
+    def is_fifo(_) -> bool:
+        return _._path.is_fifo()
+
+    def is_file(_) -> bool:
+        return _._path.is_file()
+
+    def is_mount(_) -> bool:
+        return _._path.is_mount()
+
+    def is_relative_to(_, *other):
+        other = [x._path if isinstance(x, _.__class__) else x for x in other]
+        return _._path.is_relative_to(*other)
+
+    def is_reserved(_) -> bool:
+        return _._path.is_reserved()
+
+    def is_socket(_) -> bool:
+        return _._path.is_socket()
+
+    def is_symlink(_) -> bool:
+        return _._path.is_symlink()
+
+    def iterdir(_):
+        for i in _._path.iterdir():
+            yield _.__class__(i)
+
+    def joinpath(_, *other):
+        return _.castToPath(_._path.joinpath(*other))
+
+    def lchmod(_, mode):
+        return _.castToPath(_._path.lchmod(mode))
+
+    def link_to(_, target):
+        if isinstance(target, _.__class__ | pathlib.Path):
+            target = str(target)
+        return _.castToPath(_._path.link_to(target))
+
+    def lstat(_):
+        return _.castToPath(_._path.lstat())
+
+    def match(_, pattern):
+        return _.castToPath(_._path.match(pattern))
+
+    def mkdir(_, mode=0o700, parents=F, exist_ok=F):
+        _._path.mkdir(mode=mode, parents=parents, exist_ok=exist_ok)
+        return _
+
+    def open(_, mode='r', buffering=-1, encoding=N, errors=N, newline=N):
+        return _.castToPath(
+            _._path.open(
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                errors=errors,
+                newline=newline,
+            )
+        )
+
+    def owner(_):
+        return _.castToPath(_._path.owner())
+
+    def read_bytes(_):
+        return _._path.read_bytes()
+
+    def read_text(_, encoding=N, errors=N):
+        return _._path.read_text(encoding=encoding, errors=errors)
+
+    def readlink(_):
+        return _.castToPath(_._path.readlink())
+
+    def readlinkFull(_):
+        path = _._path
+        while path.is_symlink():
+            path = path.absolute()
+            path = path.readlink()
+        if not path.is_absolute():
+            path = (_._path if _._path.is_dir() else _._path.parent) / path
+        path = path.resolve()
+        return _.castToPath(path)
+
+    def relative_to(_, *other):
+        other = [x._path if isinstance(x, _.__class__) else x for x in other]
+        return _.clone(_._path.relative_to(*other))
+
+    def rename(_, target):
+        return _.castToPath(_._path.rename(str(target)))
+
+    move = rename
+    mv = rename
+
+    def replace(_, target):
+        return _.castToPath(_._path.replace(target))
+
+    def resolve(_, strict=F):
+        return _.castToPath(_._path.resolve(strict=strict))
+
+    def rglob(_, pattern):
+        raise NotImplementedError()
+        return _.castToPath(_._path.rglob(pattern))
+
+    def rmdir(_, logTo: callable = N):
+        if logTo:
+            logTo(f'{cl.mag}rmdir{cl.r} {cl.yel}{_._path}{cl.r}')
+        return _.castToPath(_._path.rmdir())
+
+    def samefile(_, other_path):
+        return _.castToPath(_._path.samefile(other_path))
+
+    def symlink_to(
+        _,
+        target,
+        # Ignored on unix. Required on win.
+        target_is_directory=F,
+    ):
+        target = target._path if isinstance(target, _.__class__) else target
+        return _.castToPath(_._path.symlink_to(target, target_is_directory=target_is_directory))
+
+    def touch(_, mode=0o600, exist_ok=T):
+        _.castToPath(_._path.touch(mode=mode, exist_ok=exist_ok))
+        return _
+
+    def unlink(_, missing_ok=F):
+        return _.castToPath(_._path.unlink(missing_ok=missing_ok))
+
+    def with_name(_, name):
+        return _.castToPath(_._path.with_name(name))
+
+    def with_stem(_, stem):
+        return _.castToPath(_._path.with_stem(stem))
+
+    def with_suffix(_, suffix):
+        return _.castToPath(_._path.with_suffix(suffix))
+
+    def write_bytes(_, data):
+        _._path.write_bytes(data)
+        return _
+
+    def write_text(_, data, encoding=N, errors=N, newline=N):
+        _._path.write_text(data)
+        return _
+
+    def __truediv__(_, arg):
+        return _.clone(_._path / str(arg))
+
+    # == camel
+    asPosix = as_posix
+    asUri = as_uri
+    hardlinkTo = hardlink_to
+    isAbsolute = is_absolute
+    isBlockDevice = is_block_device
+    isCharDevice = is_char_device
+    isDir = is_dir
+    isFifo = is_fifo
+    isFile = is_file
+    isMount = is_mount
+    isRelativeTo = is_relative_to
+    isReserved = is_reserved
+    isSocket = is_socket
+    isSymlink = is_symlink
+    linkTo = link_to
+    readBytes = read_bytes
+    readText = read_text
+    relativeTo = relative_to
+    symlinkTo = symlink_to
+    withName = with_name
+    withStem = with_stem
+    withSuffix = with_suffix
+    writeBytes = write_bytes
+    writeText = write_text
+
+    # == lower
+    asposix = as_posix
+    asuri = as_uri
+    hardlinkto = hardlink_to
+    isabsolute = is_absolute
+    isblockdevice = is_block_device
+    ischardevice = is_char_device
+    isdir = is_dir
+    isfifo = is_fifo
+    isfile = is_file
+    ismount = is_mount
+    isrelativeto = is_relative_to
+    isreserved = is_reserved
+    issocket = is_socket
+    issymlink = is_symlink
+    linkto = link_to
+    readbytes = read_bytes
+    readtext = read_text
+    relativeto = relative_to
+    symlinkto = symlink_to
+    withname = with_name
+    withstem = with_stem
+    withsuffix = with_suffix
+    writebytes = write_bytes
+    writetext = write_text
diff --git a/defl/_path/_permission_.py b/defl/_path/_permission_.py
new file mode 100644
index 0000000..4cc72a2
--- /dev/null
+++ b/defl/_path/_permission_.py
@@ -0,0 +1,68 @@
+import itertools
+import json, hashlib
+import os
+import pathlib
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+from .._typing_ import *
+from .._except_ import *
+
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+class _DathPermission:
+    @staticmethod
+    def ugorwx(ugo, rwx) -> Literal[256, 128, 64, 32, 16, 8, 4, 2, 1]:
+        match (ugo, rwx):
+            case ('u', 'r'):
+                return stat.S_IRUSR
+            case ('u', 'w'):
+                return stat.S_IWUSR
+            case ('u', 'x'):
+                return stat.S_IXUSR
+            case ('g', 'r'):
+                return stat.S_IRGRP
+            case ('g', 'w'):
+                return stat.S_IWGRP
+            case ('g', 'x'):
+                return stat.S_IXGRP
+            case ('o', 'r'):
+                return stat.S_IROTH
+            case ('o', 'w'):
+                return stat.S_IWOTH
+            case ('o', 'x'):
+                return stat.S_IXOTH
+        raise DathValueError(f'{ugo=} {rwx=}')
+
+    def chmodUpdate(_, *updates: list[str]):
+        if not updates:
+            if _.isFile():
+                _._path.chmod(0o600)
+            elif _.isDir():
+                _._path.chmod(0o700)
+            return
+
+        orig = _.st.st_mode
+        new = orig
+        for i in updates:
+            ugo, pm, rwx = i
+            assert ugo in ['u', 'o', 'g']
+            assert rwx in ['r', 'x', 'w']
+            assert pm in ['+', '-']
+            mode = _.ugorwx(ugo, rwx)
+            if pm == '+':
+                new = mode | new
+            else:
+                new = mode & new
+        if new != orig:
+            _.chmod(new)
+        return _
diff --git a/defl/_path/_readWrite_.py b/defl/_path/_readWrite_.py
new file mode 100644
index 0000000..5f1fa5a
--- /dev/null
+++ b/defl/_path/_readWrite_.py
@@ -0,0 +1,187 @@
+import itertools
+import json, hashlib
+import os
+import pathlib, io
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+from .._typing_ import *
+from .._except_ import *
+from ..thirdParty import jstyleson
+from .._jq_ import jload, jloads, jdump, jdumps, JqLoad
+
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+class LoadCanNotResolveExtensionError(Exception):
+    __slot__ = ()
+
+
+class FileSizeReducedError(Exception):
+    __slot__ = ()
+
+
+class _DathReadWrite:
+    # == open files
+    def _encodeData(_, data: Any, joinIter=b'\n'):
+        if inst(data, Mapping):
+            return jdumps(data, asBytes=T)
+        elif inst(data, bytearray | bytes):
+            return data
+        elif inst(data, str):
+            return data.encode('utf8')
+        elif inst(data, Iterable):
+            bytz = bytearray()
+            for item in data:
+                bytz += _._encodeData(item) + joinIter
+            return bytz
+        raise TypeError(str(type(data)))
+
+    def write(_, data: Any) -> Self:
+        with _._path.open('wb') as fp:
+            fp.write(_._encodeData(data))
+            fp.flush()
+        return _
+
+    def writeJson(_, data: Any, **args) -> Self:
+        with _._path.open('w') as fp:
+            jdump(data=data, output=fp, **args)
+        return _
+
+    def append(_, data: Any, nl: bool = T) -> Self:
+        with _._path.open('ab') as fp:
+            fp.write(_._encodeData(data))
+            if nl:
+                fp.write(b'\n')
+            fp.flush()
+        return _
+
+    def readLines(_, strip: str = '\n', removeEmpty: bool = T):
+        with _._path.open('r') as fp:
+            while line := fp.readline():
+                if strip:
+                    line = line.strip(strip)
+                if removeEmpty and not line.strip():
+                    continue
+                yield line
+
+    def readLinesBin(_):
+        with _._path.open('rb') as fp:
+            while line := fp.readline():
+                yield line
+
+    # == load
+    def load(_, onNotExist: Any = ..., onLoadFail: Any = ...):
+        if not _.exists():
+            if onNotExist is not ...:
+                return onNotExist() if callable(onNotExist) else onNotExist
+            raise FileNotFoundError(f'{_}')
+        sfx = _.suffix.lower()
+        func = {
+            '.json': _.loadJson,
+            '.jsonl': _.loadJsonl,
+            '.jsonc': _.loadJsonc,
+            '.toml': _.loadToml,
+            '.ini': _.loadIni,
+        }.get(sfx)
+
+        if not func:
+            raise LoadCanNotResolveExtensionError(f'suffix={sfx!r}')
+
+        try:
+            try:
+                return func()
+            except json.decoder.JSONDecodeError as e:
+                # TODO toml jsonc ini csv
+                if onLoadFail is not ...:
+                    return onLoadFail() if callable(onLoadFail) else onLoadFail
+                raise e
+        except Exception as e:
+            e.add_note(f'function={func}')
+            raise e
+
+    def loadJson(_):
+        try:
+            return jloads(_.readText())
+        except json.decoder.JSONDecodeError as e:
+            e.add_note(str(_))
+            raise e
+
+    def loadJsonl(_):
+        with _.open('rb') as fp:
+            yield from JqLoad().fromFile(fp)
+
+    def loadJsonc(_):
+        return jstyleson.loads(_.readText())
+
+    def loadToml(_):
+        return toml.loads(_.readText())
+
+    def loadIni(_):
+        from configparser import RawConfigParser
+
+        config = RawConfigParser()
+        config.read(str(_._path))
+        dictionary = {}
+        for section in config.sections():
+            dictionary[section] = {}
+            for option in config.options(section):
+                dictionary[section][option] = config.get(section, option)
+        return dictionary
+
+    # == save
+    def saveJson(_, data) -> N:
+        raise NotImplementedError('')
+        _.writeText(json.dumps(data, indent=2))
+
+    def saveJsonl(_, data) -> N:
+        raise NotImplementedError('')
+        with _._path.open('w') as fp:
+            for i in data:
+                JqDump(output=fp).dump(i)
+
+    def saveJsonc(_) -> N:
+        raise NotImplementedError('')
+
+    def saveToml(_) -> N:
+        raise NotImplementedError('')
+
+    def saveIni(_) -> N:
+        raise NotImplementedError('')
+
+    # == other
+    def countLines(_) -> int:
+        totLines = 0
+        with _.open('r') as fp:
+            while fp.readline():
+                totLines += 1
+        return totLines
+
+    def assertSizeDoesNotReduce(_) -> Generator[int, N, N]:
+        size = _.size()
+        while T:
+            yield size
+            if (newSize := _.size()) < size:
+                raise FileSizeReducedError(_)
+            size = newSize
+
+    def assertSizeDoesNotReduceFp(_, fp: io.FileIO) -> Generator[int, N, N]:
+        # TODO not thread safe
+        size = 0
+        while T:
+            cur = fp.tell()
+            fp.seek(0, 2)
+            newSize = fp.tell()
+            fp.seek(cur)
+            if newSize < size:
+                raise FileSizeReducedError(_)
+            size = newSize
+            yield size
diff --git a/defl/_path/_static_.py b/defl/_path/_static_.py
new file mode 100644
index 0000000..8ea905b
--- /dev/null
+++ b/defl/_path/_static_.py
@@ -0,0 +1,62 @@
+import itertools
+import json, hashlib
+import os
+import pathlib
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+from .._typing_ import *
+from .._except_ import *
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class StaticPath:
+    _cache: dict = field(default_factory=dict, kw_only=T, repr=T)
+
+    @property
+    def home(_) -> _Dath:
+        from .._path_ import Dath as _Dath
+
+        if 'home' not in _._cache:
+            _._cache['home'] = _Dath(os.environ['HOME'])
+        return _._cache['home']
+
+    @property
+    def tmp(_) -> _Dath:
+        if 'tmp' not in _._cache:
+            _._cache['tmp'] = (_.home / 'tmp').makeDir()
+        return _._cache['tmp']
+
+    @property
+    def log(_) -> _Dath:
+        if 'log' not in _._cache:
+            _._cache['log'] = (_.home / 'log').makeDir()
+        return _._cache['log']
+
+    @property
+    def shm(_) -> _Dath:
+        from .._path_ import Dath as _Dath
+
+        if 'shm' not in _._cache:
+            _._cache['shm'] = _Dath(f'/dev/shm/{user}')
+        return _._cache['shm']
+
+
+staticPath = StaticPath()
+sp = staticPath
+
+
+def _NotInitable(*args, **kargs):
+    raise DathNotInitableError()
+
+
+StaticPath.__init__ = _NotInitable
diff --git a/defl/_path/_temp_.py b/defl/_path/_temp_.py
new file mode 100644
index 0000000..6a41c20
--- /dev/null
+++ b/defl/_path/_temp_.py
@@ -0,0 +1,132 @@
+import itertools
+import json, hashlib
+import os
+import pathlib
+import re
+import shlex
+import shutil
+import stat
+from contextlib import contextmanager
+from dataclasses import dataclass
+import base64
+import toml
+from .._typing_ import *
+from .._except_ import *
+from .._time_ import Time
+from .._basic_ import Enumer
+
+_Dath = TypeVar('_Dath')
+if TYPE_CHECKING:
+    from .._path_ import Dath as _Dath
+
+
+class TempPathItem(Enumer):
+    Name = enum.auto()
+    Date = enum.auto()
+    Index = enum.auto()
+    Ext = enum.auto()
+    Random = enum.auto()
+
+
+_TPI = TempPathItem
+
+
+class TempPathNoIndexInFmtError(Exception):
+    __slot__ = ()
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class TempPath:
+    path: _Dath
+    join: str = '_'
+
+    _comp: list[Any] = field(default_factory=list)
+
+    TNI: ClassVar = TempPathItem
+    TempPathNoIndexInFmtError: ClassVar = TempPathNoIndexInFmtError
+    fmt: list[str] = field(default_factory=lambda: [_TPI.Name, _TPI.Date, _TPI.Index, _TPI.Ext])
+
+    def __post_init__(_) -> N:
+        if _.TNI.Index not in _.fmt:
+            raise TempPathNoIndexInFmtError()
+
+    _ext: str = N
+    _name: str = N
+
+    def setName(_, name: Any) -> Self:
+        if name:
+            _._name = str(name)
+        return _
+
+    def setExt(_, ext: str) -> Self:
+        if ext:
+            _._ext = str(ext)
+        return _
+
+    def generate(_) -> Generator[_Dath, N, N]:
+        # TODO except OSError and e.errno==36 # (36, 'File name too long')
+        index = 0
+        while T:
+            name = []
+            for x in _.fmt:
+                match x:
+                    case TempPathItem.Name:
+                        if name:
+                            name.append('_')
+                        if _._name:
+                            name.append(_._name)
+                    case TempPathItem.Ext:
+                        if _._ext:
+                            if not _._ext.startswith('.'):
+                                name.append('.')
+                            name.append(_._ext)
+                    case TempPathItem.Index:
+                        if index > 0:
+                            if name:
+                                name.append('_')
+                            name.append(f'{index:0>5d}')
+                    case TempPathItem.Date:
+                        if name:
+                            name.append('_')
+                        d = Time(fmt=Time.Fmt.ymdhmsNoSpace).toStr()
+                        name.append(d)
+                    case __:
+                        raise NotImplementedError(f'no match for {x}')
+            yield _.path / ''.join(name)
+            index += 1
+
+    @staticmethod
+    def MakeTempPath(
+        path: _Dath,  # | this is self of `Dath` because this function is called in _PathTemp which is mixin of Dath
+        name: str | Iterable,
+        /,
+        autoRemove: bool,
+        create: bool,
+        direct: bool,
+        ext: str = N,
+        fmt: list[TempPathItem] = N,
+    ) -> _Dath:
+        if not inst(name, str):
+            name = '_'.join(name)
+        tmp = TempPath(path=path).setExt(ext).setName(name)
+        for p in tmp.generate():
+            if not p.exists():
+                break
+        p = path.__class__(p)
+        if autoRemove:
+            p.addOnDelFunc(partial(p.remove, recursive=T))
+        if create:
+            p.makeDir() if direct else p.createFile()
+        return p
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class _PathTemp:
+    makeTemp = TempPath.MakeTempPath
+
+    def latestTemp(_, name: str, one: bool = T) -> _Dath | list[_Dath]:
+        paths = _.glob(name + '_*')  # | symmetric with `_.makeTemp(name=...)`
+        paths = sorted(paths, key=lambda x: x.name)
+        if one:
+            paths = paths[-1] if paths else N
+        return paths
diff --git a/defl/_path/_utils_.py b/defl/_path/_utils_.py
new file mode 100644
index 0000000..aef69fd
--- /dev/null
+++ b/defl/_path/_utils_.py
@@ -0,0 +1,190 @@
+import atexit
+import itertools
+import os, shutil
+import re
+from contextlib import contextmanager
+from dataclasses import KW_ONLY, dataclass
+
+from .._basic_ import flattenNested, Enumer
+from .._logger_ import log
+from .._path_ import Dath, currentWorkingDir
+from .._runCommand_ import CommandFailedException, RunCom
+from .._system_ import CommandNotFound, platformResolve
+from .._typing_ import *
+from .._run_ import Run
+from .._rich_ import richReprAuto
+
+
+def which(com: str, raiseOnFail: bool = F) -> Dath:
+    r = shutil.which(str(com))
+    if r:
+        return Dath(r)
+    if raiseOnFail:
+        raise CommandNotFound(com)
+
+
+class LockExists(Exception): ...
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class LockFile:
+    # TODO access time older then auto remove
+    path: Dath = field(kw_only=F, repr=T)
+    wait: bool
+    rmOnExit: bool = T
+    waitLog: bool = T
+
+    def __post_init__(_):
+        _.path = Dath(_.path)
+
+    def _rmOnExitFun(_):
+        if _.path.exists():
+            _.path.remove()
+
+    def isSet(_):
+        return _.path.exists()
+
+    def aquire(_, checkInterval: float = 0.5):
+        while _.path.exists():
+            if _.wait:
+                if _.waitLog:
+                    log.info('waiting for lock file', _.path, tgt='err', end='')
+                while _.path.exists():
+                    sleep(checkInterval)
+                if _.waitLog:
+                    log.info('', tgt='err', end='')
+            else:
+                raise LockExists(_.path)
+
+        # print('created lock file', _.path, tgt='err')
+        _.path.touch()
+        if _.rmOnExit:
+            atexit.register(_._rmOnExitFun)
+
+    def remove(_):
+        # print('removing lock file', _.path, tgt='err')
+        _.path.remove()
+        if _.rmOnExit:
+            atexit.unregister(_._rmOnExitFun)
+
+    __enter__ = aquire
+
+    def __exit__(_, *args, **kargs):
+        _.remove()
+
+
+@contextmanager
+def changeWorkingDir(path):
+    prevDir = currentWorkingDir()
+    os.chdir(str(path))
+    try:
+        yield
+    finally:
+        os.chdir(str(prevDir.absolute()))
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class Find:
+    pattern: str = field(default='.', kw_only=F, repr=T)
+    options: list = field(default_factory=list)
+
+    def __post_init__(_) -> None:
+        _.options.extend(['--color', 'never', '--no-ignore', '--hidden'])
+
+    def run(
+        _,
+        *path,
+        relTo: bool = F,
+    ):
+        assert inst(relTo, bool)
+        assert _.pattern is not None
+        assert path
+        if relTo:
+            assert len(path) == 1
+            cmd = ['fd', *_.options, '--base-directory', path[0], '--', _.pattern]
+        else:
+            cmd = ['fd', *_.options, '--', _.pattern, *path]
+        run: Run = Run(cmd).setThreadRead().setLogTo().run(T, T)
+        while run.outReader.hasMore():
+            for line in run.out:
+                yield Dath(line.decode())
+        run.wait().assSuc()
+
+    def setOption(_, key: str, val: Any) -> Self:
+        _.options.append(f'--{key}')
+        if val is not None:
+            _.options.append(val)
+        return _
+
+    def setPattern(_, val: str) -> Self:
+        _.pattern = val
+        return _
+
+    def setNoHidden(_) -> Self:
+        if '--hidden' in _.options:
+            _.options.pop('--hidden')
+        return _
+
+    def setIgnore(_) -> Self:
+        if '--no-ignore' in _.options:
+            _.options.pop('--no-ignore')
+        return _
+
+    def setCaseSensitive(_) -> Self:
+        return _.setOption('case-sensitive', None)
+
+    def setIgnoreCase(_) -> Self:
+        return _.setOption('ignore-case', None)
+
+    def setGlob(_) -> Self:
+        return _.setOption('glob', None)
+
+    def setAbsolutePath(_) -> Self:
+        return _.setOption('absolute-path', None)
+
+    def setListDetails(_) -> Self:
+        return _.setOption('list-details', None)
+
+    def setFollow(_) -> Self:
+        return _.setOption('follow', None)
+
+    def setFullPath(_) -> Self:
+        return _.setOption('full-path', None)
+
+    def setMaxDepth(_, depth: int) -> Self:
+        return _.setOption('max-depth', depth)
+
+    def setExclude(_, *pattern: str) -> Self:
+        for i in pattern:
+            _.setOption('exclude', i)
+        return _
+
+    def setType(_, filetype: str) -> Self:
+        return _.setOption('type', filetype)
+
+    def setExtension(_, ext: str) -> Self:
+        return _.setOption('extension', ext)
+
+    def setSize(_, size: str) -> Self:
+        return _.setOption('size', size)
+
+    def setChangedWithin(_, dateOrDur: str) -> Self:
+        return _.setOption('changed-within', dateOrDur)
+
+    def setChangedBefore(_, dateOrDur: str) -> Self:
+        return _.setOption('changed-before', dateOrDur)
+
+    def setOwner(_, userGroup: str) -> Self:
+        return _.setOption('owner', userGroup)
+
+    def setFormat(_, fmt: str) -> Self:
+        return _.setOption('format', fmt)
+
+    def setExec(_, cmd: str) -> Self:
+        return _.setOption('exec', cmd)
+
+    def setExecBatch(_, cmd: str) -> Self:
+        return _.setOption('exec-batch', cmd)
+
+    def setColor(_, when: str) -> Self:
+        return _.setOption('color', when)
diff --git a/defl/_pathUtils_.py b/defl/_pathUtils_.py
index dc91aad..7d2cec4 100644
--- a/defl/_pathUtils_.py
+++ b/defl/_pathUtils_.py
@@ -1,188 +1 @@
-import atexit
-import itertools
-import os, shutil
-import re
-from contextlib import contextmanager
-from dataclasses import KW_ONLY, dataclass
-
-from ._basic_ import flattenNested, Enumer
-from ._logger_ import log
-from ._path_ import Dath, currentWorkingDir
-from ._runCommand_ import CommandFailedException, RunCom
-from ._system_ import CommandNotFound, platformResolve
-from ._typing_ import *
-from ._run_ import Run
-from ._rich_ import richReprAuto
-
-
-def which(com: str, raiseOnFail: bool = F) -> Dath:
-    r = shutil.which(str(com))
-    if r:
-        return Dath(r)
-    if raiseOnFail:
-        raise CommandNotFound(com)
-
-
-class LockExists(Exception): ...
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class LockFile:
-    # TODO access time older then auto remove
-    path: Dath = field(kw_only=F, repr=T)
-    wait: bool
-    rmOnExit: bool = T
-    waitLog: bool = T
-
-    def __post_init__(_):
-        from .inotify_ import INotifyWait
-
-        _.path = Dath(_.path)
-
-    def _rmOnExitFun(_):
-        if _.path.exists():
-            _.path.remove()
-
-    def isSet(_):
-        return _.path.exists()
-
-    def aquire(_):
-        while _.path.exists():
-            if _.wait:
-                if _.waitLog:
-                    log.info('waiting for lock file', _.path, tgt='err', end='')
-                while _.path.exists():
-                    sleep(0.5)
-                if _.waitLog:
-                    log.info('', tgt='err', end='')
-            else:
-                raise LockExists(_.path)
-
-        # print('created lock file', _.path, tgt='err')
-        _.path.touch()
-        if _.rmOnExit:
-            atexit.register(_._rmOnExitFun)
-
-    def remove(_):
-        # print('removing lock file', _.path, tgt='err')
-        _.path.remove()
-        if _.rmOnExit:
-            atexit.unregister(_._rmOnExitFun)
-
-    __enter__ = aquire
-
-    def __exit__(_, *args, **kargs):
-        _.remove()
-
-
-@contextmanager
-def changeWorkingDir(path):
-    prevDir = currentWorkingDir()
-    os.chdir(str(path))
-    try:
-        yield
-    finally:
-        os.chdir(str(prevDir.absolute()))
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class Find:
-    pattern: str = field(default='.', kw_only=F, repr=T)
-    options: list = field(default_factory=list)
-
-    def __post_init__(_) -> None:
-        _.options.extend(['--color', 'never', '--no-ignore', '--hidden'])
-
-    def run(_, *path, relTo: bool = F):
-        assert inst(relTo, bool)
-        assert _.pattern is not None
-        assert path
-        if relTo:
-            assert len(path) == 1
-            cmd = ['fd', *_.options, '--base-directory', path[0], '--', _.pattern]
-        else:
-            cmd = ['fd', *_.options, '--', _.pattern, *path]
-        run: Run = Run(cmd).setThreadRead().run(T, T)
-        while run.outReader.hasMore():
-            for line in run.out:
-                yield Dath(line.decode())
-        run.wait().assSuc()
-
-    def setOption(_, key: str, val: Any) -> Self:
-        _.options.append(f'--{key}')
-        if val is not None:
-            _.options.append(val)
-        return _
-
-    def setPattern(_, val: str) -> Self:
-        _.pattern = val
-        return _
-
-    def setNoHidden(_) -> Self:
-        if '--hidden' in _.options:
-            _.options.pop('--hidden')
-        return _
-
-    def setIgnore(_) -> Self:
-        if '--no-ignore' in _.options:
-            _.options.pop('--no-ignore')
-        return _
-
-    def setCaseSensitive(_) -> Self:
-        return _.setOption('case-sensitive', None)
-
-    def setIgnoreCase(_) -> Self:
-        return _.setOption('ignore-case', None)
-
-    def setGlob(_) -> Self:
-        return _.setOption('glob', None)
-
-    def setAbsolutePath(_) -> Self:
-        return _.setOption('absolute-path', None)
-
-    def setListDetails(_) -> Self:
-        return _.setOption('list-details', None)
-
-    def setFollow(_) -> Self:
-        return _.setOption('follow', None)
-
-    def setFullPath(_) -> Self:
-        return _.setOption('full-path', None)
-
-    def setMaxDepth(_, depth: int) -> Self:
-        return _.setOption('max-depth', depth)
-
-    def setExclude(_, *pattern: str) -> Self:
-        for i in pattern:
-            _.setOption('exclude', i)
-        return _
-
-    def setType(_, filetype: str) -> Self:
-        return _.setOption('type', filetype)
-
-    def setExtension(_, ext: str) -> Self:
-        return _.setOption('extension', ext)
-
-    def setSize(_, size: str) -> Self:
-        return _.setOption('size', size)
-
-    def setChangedWithin(_, dateOrDur: str) -> Self:
-        return _.setOption('changed-within', dateOrDur)
-
-    def setChangedBefore(_, dateOrDur: str) -> Self:
-        return _.setOption('changed-before', dateOrDur)
-
-    def setOwner(_, userGroup: str) -> Self:
-        return _.setOption('owner', userGroup)
-
-    def setFormat(_, fmt: str) -> Self:
-        return _.setOption('format', fmt)
-
-    def setExec(_, cmd: str) -> Self:
-        return _.setOption('exec', cmd)
-
-    def setExecBatch(_, cmd: str) -> Self:
-        return _.setOption('exec-batch', cmd)
-
-    def setColor(_, when: str) -> Self:
-        return _.setOption('color', when)
+from ._path._utils_ import *
diff --git a/defl/_path_.py b/defl/_path_.py
index 6a2f2e3..3f3302c 100644
--- a/defl/_path_.py
+++ b/defl/_path_.py
@@ -22,211 +22,32 @@ from ._string_ import randomString
 from ._time_ import Time
 from ._jq_ import jloads, JqLoad, JqDump, jdump
 from ._shell_ import expandEnvVar
+from ._path._except_ import *
+from ._path._filter_ import *
+from ._path._static_ import staticPath, sp, StaticPath
+from ._path._pathlib_ import _DathPathlib
+from ._path._temp_ import _PathTemp
+from ._path._depricated_ import _PathPatch
+from ._path._assertions_ import _DathAssertions
+from ._path._readWrite_ import _DathReadWrite
+from ._path._permission_ import _DathPermission
+from ._path._metaData_ import _DathMetaData
+
 
 Dath = TypeVar('Dath')
 
+
 # TODO path is on same filesystem
 # TODO _.castToPath to Dath.clone()
 
 
-class DathValueError(Exception):
-    __slot__ = ()
-
-
-class DathNotInitableError(Exception):
-    __slot__ = ()
-
-
-class DathNotExistsError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsAbsoluteError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsBlockDeviceError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsCharDeviceError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsDirError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsFifoError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsFileError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsMountError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsRelativeToError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsReservedError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsSocketError(Exception):
-    __slot__ = ()
-
-
-class DathNotIsSymlinkError(Exception):
-    __slot__ = ()
-
-
-class DathValueError(Exception):
-    __slot__ = ()
-
-
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-# ◼◼ PATH FILTER
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class PathFilter:
-    # TODO -mount Don't descend directories on  other  filesystems.
-    file: bool = F
-    blockDevice: bool = F
-    charDevice: bool = F
-    dir: bool = F
-    fifo: bool = F
-    mount: bool = F
-    reserved: bool = F
-    socket: bool = F
-    link: bool = F
-    test: MicroLang | Iterable | none = N
-
-    def __post_init__(_):
-        if not (_.file or _.blockDevice or _.charDevice or _.dir or _.fifo or _.mount or _.reserved or _.socket):
-            _.file = T
-            _.blockDevice = T
-            _.charDevice = T
-            _.dir = T
-            _.fifo = T
-            _.mount = T
-            _.reserved = T
-            _.socket = T
-        if _.test and not isinstance(_.test, MicroLang):
-            _.test = MicroLang(_.test)
-
-    def match(_, path: Dath | pathlib.Path | str):
-        if isinstance(path, str):
-            path = Dath(path)
-        return (
-            (
-                (_.file and path.is_file())
-                or (_.dir and path.is_dir())
-                or (_.blockDevice and path.is_block_device())
-                or (_.charDevice and path.is_char_device())
-                or (_.fifo and path.is_fifo())
-                or (_.mount and path.is_mount())
-                or (_.reserved and path.is_reserved())
-                or (_.socket and path.is_socket())
-            )
-            and ((not _.link and not path.is_symlink()) or (_.link and path.is_symlink()))
-            and (not _.test or _.test.eval(path))
-        )
-
-    def filterMany(_, *paths: Iterable, glob: str = N) -> dict:
-        paths = listFromArgsStar(*paths)
-        for x in paths:
-            if glob:
-                for y in x.glob(glob):
-                    if _.match(y):
-                        yield y
-            elif _.match(x):
-                yield x
-
-
-def ugorwx(ugo, rwx) -> Literal[256, 128, 64, 32, 16, 8, 4, 2, 1]:
-    match (ugo, rwx):
-        case ('u', 'r'):
-            return stat.S_IRUSR
-        case ('u', 'w'):
-            return stat.S_IWUSR
-        case ('u', 'x'):
-            return stat.S_IXUSR
-        case ('g', 'r'):
-            return stat.S_IRGRP
-        case ('g', 'w'):
-            return stat.S_IWGRP
-        case ('g', 'x'):
-            return stat.S_IXGRP
-        case ('o', 'r'):
-            return stat.S_IROTH
-        case ('o', 'w'):
-            return stat.S_IWOTH
-        case ('o', 'x'):
-            return stat.S_IXOTH
-    raise DathValueError(f'{ugo=} {rwx=}')
-
-
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-# ◼◼ STATIC PATH
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-@dataclass(slots=T, kw_only=T, frozen=F)
-class StaticPath:
-    _cache: dict = field(default_factory=dict, kw_only=T, repr=T)
-
-    @property
-    def home(_) -> Dath:
-        if 'home' not in _._cache:
-            _._cache['home'] = Dath(os.environ['HOME'])
-        return _._cache['home']
-
-    @property
-    def tmp(_) -> Dath:
-        if 'tmp' not in _._cache:
-            _._cache['tmp'] = (_.home / 'tmp').makeDir()
-        return _._cache['tmp']
-
-    @property
-    def log(_) -> Dath:
-        if 'log' not in _._cache:
-            _._cache['log'] = (_.home / 'log').makeDir()
-        return _._cache['log']
-
-    @property
-    def shm(_) -> Dath:
-        if 'shm' not in _._cache:
-            _._cache['shm'] = Dath(f'/dev/shm/{user}')
-        return _._cache['shm']
-
-
-staticPath = StaticPath()
-sp = staticPath
-
-
-def NotInitable(*args, **kargs):
-    raise DathNotInitableError()
-
-
-StaticPath.__init__ = NotInitable
-
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-# ◼◼ PATH
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-
-class Dath:
-    __slots__ = ('_path', '_pathStr', '_stat', '_onDel')
+class Dath(_DathPathlib, _PathTemp, _DathAssertions, _DathReadWrite, _DathPermission, _DathMetaData):
+    # TODO use mixin classes to seperate all these functions
+    __slots__ = ('_path', '_pathStr', '_onDel')
 
     def __init__(_, *args):
         _._path: pathlib.Path = N
         _._pathStr: str | none = N
-        _._stat: os.stat_result = N
         _._onDel: list | N = N
 
         # == build path
@@ -247,29 +68,6 @@ class Dath:
                 kargs[i] = getattr(_, i)
         return Dath(*args, **kargs)
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ constructor
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    @classmethod
-    def Temp(cls):  #!depricate
-        tmp = Dath('~/tmp/').makeDir()  #!depricate
-        return tmp  #!depricate
-
-    @classmethod  #!depricate
-    def Shm(cls):  #!depricate
-        user = os.environ['USER']  #!depricate
-        tmp = Dath(f'/dev/shm/{user}').makeDir()  #!depricate
-        return tmp  #!depricate
-
-    @classmethod  #!depricate
-    def FromEnv(cls, var: str, orElse: str | N = N):  #!depricate
-        return cls(os.environ.get(var, orElse))  #!depricate
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ helper
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
     _reduceSlashReg = re.compile(r'(/+)')
 
     @staticmethod
@@ -284,9 +82,7 @@ class Dath:
             val = _.clone(val)
         return val
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ properties
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
+    # == properties
 
     @property
     def sp(_) -> StaticPath:
@@ -302,9 +98,7 @@ class Dath:
 
     @property
     def st(_):
-        if not _._stat:
-            _._stat = _._path.stat()
-        return _._stat
+        return _._path.stat()
 
     @property
     def str(_):
@@ -336,9 +130,7 @@ class Dath:
     def isHidden(_):
         return _.name.startswith('.')
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ functions
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
+    # == functions
     def gitRepoRoot(_) -> Dath:
         gitRoot = _
         while not (gitRoot / '.git').exists():
@@ -409,31 +201,6 @@ class Dath:
     def FromParts(*parts):
         return Dath(Dath._fromParts(*parts))
 
-    def chmodUpdate(_, *updates: list[str]):
-        if not updates:
-            if _.isFile():
-                _._path.chmod(0o600)
-            elif _.isDir():
-                _._path.chmod(0o700)
-            return
-
-        orig = _.st.st_mode
-        new = orig
-        for i in updates:
-            ugo, pm, rwx = i
-            assert ugo in ['u', 'o', 'g']
-            assert rwx in ['r', 'x', 'w']
-            assert pm in ['+', '-']
-            mode = ugorwx(ugo, rwx)
-            if pm == '+':
-                new = mode | new
-            else:
-                new = mode & new
-        if new != orig:
-            _.chmod(new)
-        _._stat = N
-        return _
-
     def ls(_, pathFilter: PathFilter = N):
         return (Dath(x) for x in _._path.glob('*') if not pathFilter or pathFilter.filter(x))
 
@@ -514,30 +281,6 @@ class Dath:
     reExt = newExt
     reSuffix = newExt
 
-    def tempFile(  # TODO rename temp
-        _,
-        autoRemove: bool = T,
-        create: bool = T,
-        fmt: str = '{d}_{r}',
-        direct: bool = F,
-    ) -> Dath:
-        p = N
-        while p is none or p.exists():
-            d = Time(fmt='%Y-%m-%d_%H-%M-%S-%f').toStr()
-            r = randomString(10)
-            p = _._path / fmt.format(d=d, r=r)
-        p = Dath(p)
-        if autoRemove:
-            p.addOnDelFunc(partial(p.remove, recursive=T))
-        if create:
-            if direct:
-                p.makeDir()
-            else:
-                p.createFile()
-        return p
-
-    temp = tempFile
-
     def setAccModTime(_, access=F, modify=F) -> Self:
         if access is F:
             access = _.st.access
@@ -550,7 +293,6 @@ class Dath:
             modify = datetime.now().timestamp()
 
         os.utime(_._path, (access, modify))
-        _._stat = N
         return _
 
     def newNameIfExists(_, fmt='{name}_{index:06}{suffixes}') -> Self:
@@ -573,167 +315,28 @@ class Dath:
         """
         return _._path.suffix.strip('.')
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ open files
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    def _encodeData(_, data: Any, joinIter=b'\n'):
-        if inst(data, Mapping):
-            raise NotImplementedError('Use defl._jq_ module')
-        elif inst(data, bytearray | bytes):
-            return data
-        elif inst(data, str):
-            return data.encode('utf8')
-        elif inst(data, Iterable):
-            bytz = bytearray()
-            for item in data:
-                bytz += _._encodeData(item) + joinIter
-            return bytz
-        raise TypeError(str(type(data)))
-
-    def write(_, data: Any) -> Self:
-        with _._path.open('wb') as fp:
-            fp.write(_._encodeData(data))
-            fp.flush()
-        return _
-
-    def writeJson(_, data: Any) -> Self:
-        with _._path.open('w') as fp:
-            jdump(data=data, output=fp)
-        return _
-
-    def append(_, data: Any, nl: bool = T) -> Self:
-        with _._path.open('ab') as fp:
-            fp.write(_._encodeData(data))
-            if nl:
-                fp.write(b'\n')
-            fp.flush()
-        return _
-
-    def appendText(_, data: Any, **kargs) -> Self:
-        "#!depricated"
-        if inst(data, bytes | bytearray):  #!depricate
-            mode = 'ab'  #!depricate
-        else:  #!depricate
-            mode = 'a'  #!depricate
-            data = str(data)  #!depricate
-        with _._path.open(mode, **kargs) as fp:  #!depricate
-            fp.write(data)  #!depricate
-            fp.flush()
-        return _  #!depricate
-
-    def appendLine(_, data: Any, **kargs):  #!depricate
-        "#!depricated"
-        _.appendText(f'{data}\n', **kargs)  #!depricate
-
-    def readLines(_, strip: str = '\n', removeEmpty: bool = T):
-        with _._path.open('r') as fp:
-            while line := fp.readline():
-                if strip:
-                    line = line.strip(strip)
-                if removeEmpty and not line.strip():
-                    continue
-                yield line
-
-    def readLinesBin(_):
-        with _._path.open('rb') as fp:
-            while line := fp.readline():
-                yield line
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ load
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    def load(_):
-        return {
-            '.json': _.loadJson,
-            '.jsonl': _.loadJsonl,
-            '.jsonc': _.loadJsonc,
-            '.toml': _.loadToml,
-            '.ini': _.loadIni,
-        }[_.suffix.lower()]()
-
-    def loadJson(_):
-        try:
-            return jloads(_.readText())
-        except json.decoder.JSONDecodeError as e:
-            e.add_note(str(_))
-            raise e
-
-    def loadJsonl(_):
-        with _.open('rb') as fp:
-            yield from JqLoad().fromFile(fp)
-
-    def loadJsonc(_):
-        return jstyleson.loads(_.readText())
-
-    def loadToml(_):
-        return toml.loads(_.readText())
-
-    def loadIni(_):
-        from configparser import RawConfigParser
-
-        config = RawConfigParser()
-        config.read(str(_._path))
-        dictionary = {}
-        for section in config.sections():
-            dictionary[section] = {}
-            for option in config.options(section):
-                dictionary[section][option] = config.get(section, option)
-        return dictionary
-
-    jsonc = loadJsonc  # TODO depricate
-    json = loadJson  # TODO depricate
-    toml = loadToml  # TODO depricate
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ save
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    def saveJson(_, data) -> N:
-        raise NotImplementedError('')
-        _.writeText(json.dumps(data, indent=2))
-
-    def saveJsonl(_, data) -> N:
-        raise NotImplementedError('')
-        with _._path.open('w') as fp:
-            for i in data:
-                JqDump(output=fp).dump(i)
-
-    def saveJsonc(_) -> N:
-        raise NotImplementedError('')
-
-    def saveToml(_) -> N:
-        raise NotImplementedError('')
-
-    def saveIni(_) -> N:
-        raise NotImplementedError('')
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ dunder
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
+    # == dunder
 
     def toJson(_):
         return str(_._path)
 
     def __repr__(_) -> str:
-        # TODO use __file__ to put module name
-        return f'{cl.mag}λ({cl.r}{cl.yel}{_._path.parent}{cl.r}/{cl.cyn}{_._path.name}{cl.r}{cl.mag}){cl.r}'
+        return f'λ({_._path})'
 
     def __str__(_) -> str:
         return str(_._path)
 
     def __hash__(_) -> str:
-        return _._path.__hash__()
+        return hash(_._path)
 
     def __del__(_):
-        if _._onDel:
-            for i in _._onDel:
-                i()
-        del _._path
+        if hasattr(_, '_onDel'):
+            if _._onDel:
+                for i in _._onDel:
+                    i()
+            del _._path
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ parts
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
+    # == parts
 
     @staticmethod
     def _normalizeFromComponents(*args) -> str:
@@ -750,15 +353,14 @@ class Dath:
         # args = args.rstrip('/') # DONT DO THIS bad if '/'
         return args
 
+    # TODO move component to new path?
     @staticmethod
     def _fromParts(*args) -> pathlib.Path:
         args = [str(x) if isinstance(x, int) else x for x in args]
         a = Dath._normalizeFromComponents(*args)
         return pathlib.Path(a)
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ regex minipulate
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
+    # == regex minipulate
 
     def regFindIter(_, reg: LiteralString | re.Pattern, /) -> list[re.Match]:
         if not isinstance(reg, re.Pattern):
@@ -776,9 +378,7 @@ class Dath:
             reg = re.compile(reg)
         return reg.search(_.str)
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ force create
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
+    # == force create
 
     def mkdirForce(_, mode=N):
         _.mkdir(**({'mode': mode} if mode else {}), parents=T, exist_ok=T)
@@ -795,10 +395,9 @@ class Dath:
             target = str(target)
         _.symlink_to(target=target)
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ find
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
+    # == find
 
+    # TODO depricate?
     @staticmethod
     def _subPathGen(
         subPath: Dath,
@@ -823,6 +422,7 @@ class Dath:
                     ):
                         yield i
 
+    # TODO depricate?
     def find(
         _,
         pathFilter: MicroLang | Callable = N,
@@ -853,485 +453,31 @@ class Dath:
         ):
             yield i
 
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ commands
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # from defl._runCommand_ import RunCom
-    RunComReturn = NewType('defl.RunCom', str)  # defl.RunCom
-
-    def execute(_, com, *args, **kargs) -> RunComReturn:
-        import defl
-
-        if 'pipe' not in kargs:
-            kargs['pipe'] = false
-        l = [defl.which(com), _._path]
-        l.extend(args)
-        return defl.RunCom(l, **kargs)
-
-    def vim(_, *args, startInInsert=F, **kargs) -> RunComReturn:
-        if startInInsert:
-            args += ('-c', 'startinsert')
-        return _.execute('vim', *args)
-
-    def bash(_, *args, **kargs) -> RunComReturn:
-        pass
-
-        return _.execute('bash', *args)
-
-    def python(_, *args, **kargs) -> RunComReturn:
-        pass
-
-        return _.execute('python', *args)
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ pathlib.Path properties
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    @property
-    def parts(_) -> List[str]:
-        return _._path.parts
-
-    @property
-    def drive(_) -> str:
-        """
-        Dath('/a/b/c.d.e.f').drive => ''
-        Dath('a/b/c.d.e.f').drive => ''
-        """
-        return _._path.drive
-
-    @property
-    def root(_) -> str:
-        """
-        Dath('/a/b/c.d.e.f').root => '/'
-        Dath('a/b/c.d.e.f').root => ''
-        """
-        return _._path.root
-
-    @property
-    def anchor(_) -> str:
-        """
-        Dath('/a/b/c.d.e.f').anchor => '/'
-        Dath('a/b/c.d.e.f').anchor => ''
-        """
-        return _._path.anchor
-
-    @property
-    def parents(_):  # -> Generator[Dath]:
-        """
-        Dath('/a/b/c.d.e.f').parents => <PosixPath.parents>
-        Dath('a/b/c.d.e.f').parents => <PosixPath.parents>
-        [x for x in Dath('a/b/c.d.e.f').parents] => [PosixPath('a/b'), PosixPath('a'), PosixPath('.')]
-        """
-        for i in _._path.parents:
-            yield Dath(i)
-
-    @property
-    def parent(_) -> Dath:
-        """
-        Dath('/a/b/c.d.e.f').parent => Dath('/a/b')
-        Dath('a/b/c.d.e.f').parent => Dath('a/b')
-        """
-        return Dath(_._path.parent)
-
-    @property
-    def name(_) -> str:
-        """
-        Dath('/a/b/c.d.e.f').name => 'c.d.e.f'
-        Dath('a/b/c.d.e.f').name => 'c.d.e.f'
-        """
-        return _._path.name
-
-    @property
-    def suffix(_) -> str:  # | extension
-        """
-        Dath('/a/b/c.d.e.f').suffix => '.f'
-        Dath('a/b/c.d.e.f').suffix => '.f'
-        """
-        return _._path.suffix
-
-    @property
-    def suffixes(_) -> list:
-        """
-        Dath('/a/b/c.d.e.f').suffixes => ['.d', '.e', '.f']
-        Dath('a/b/c.d.e.f').suffixes => ['.d', '.e', '.f']
-        """
-        return _._path.suffixes
-
-    @property
-    def suffixesStr(_) -> list:
-        """
-        Dath('/a/b/c.d.e.f').suffixes => '.d.e.f']
-        Dath('a/b/c.d.e.f').suffixes => '.d.e.f']
-        """
-        return ''.join(_.suffixes)
-
-    @property
-    def stem(_) -> str:
-        """
-        Dath('/a/b/c.d.e.f').stem => 'c.d.e'
-        Dath('a/b/c.d.e.f').stem => 'c.d.e'
-        """
-        return _._path.stem
-
-    @property
-    def stemBase(_) -> str:
-        # not part of pathlib
-        """
-        Dath('/a/b/c.d.e.f').stem => 'c'
-        Dath('a/b/c.d.e.f').stem => 'c'
-        """
-        return re.sub(r'\..*', '', _._path.name)
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ pathlib.Path functions
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    def absolute(_):
-        return _.castToPath(_._path.absolute())
-
-    def as_posix(_):
-        return _.castToPath(_._path.as_posix())
-
-    def as_uri(_):
-        return _.castToPath(_._path.as_uri())
-
-    def chmod(_, mode, *, follow_symlinks=T):
-        return _.castToPath(_._path.chmod(mode, follow_symlinks=follow_symlinks))
-
-    def stat(_, *, follow_symlinks=T):
-        return _._path.stat(follow_symlinks=follow_symlinks)
-
-    def exists(_) -> bool:
-        return _._path.exists()
-
-    def expanduser(_):
-        return _.castToPath(_._path.expanduser())
-
-    def glob(_, pattern):
-        for i in _._path.glob(pattern):
-            yield _.castToPath(i)
-
-    def group(_):
-        return _.castToPath(_._path.group())
-
-    def hardlink_to(_, target):
-        return _.castToPath(_._path.hardlink_to(target))
-
-    def is_absolute(_) -> bool:
-        return _._path.is_absolute()
-
-    def is_block_device(_) -> bool:
-        return _._path.is_block_device()
-
-    def is_char_device(_) -> bool:
-        return _._path.is_char_device()
-
-    def is_dir(_) -> bool:
-        return _._path.is_dir()
-
-    def is_fifo(_) -> bool:
-        return _._path.is_fifo()
-
-    def is_file(_) -> bool:
-        return _._path.is_file()
-
-    def is_mount(_) -> bool:
-        return _._path.is_mount()
-
-    def is_relative_to(_, *other):
-        other = [x._path if isinstance(x, Dath) else x for x in other]
-        return _._path.is_relative_to(*other)
-
-    def is_reserved(_) -> bool:
-        return _._path.is_reserved()
-
-    def is_socket(_) -> bool:
-        return _._path.is_socket()
-
-    def is_symlink(_) -> bool:
-        return _._path.is_symlink()
-
-    def iterdir(_):
-        for i in _._path.iterdir():
-            yield Dath(i)
-
-    def joinpath(_, *other):
-        return _.castToPath(_._path.joinpath(*other))
-
-    def lchmod(_, mode):
-        return _.castToPath(_._path.lchmod(mode))
-
-    def link_to(_, target):
-        if isinstance(target, Dath | pathlib.Path):
-            target = str(target)
-        return _.castToPath(_._path.link_to(target))
-
-    def lstat(_):
-        return _.castToPath(_._path.lstat())
-
-    def match(_, pattern):
-        return _.castToPath(_._path.match(pattern))
-
-    def mkdir(_, mode=0o700, parents=F, exist_ok=F):
-        _._path.mkdir(mode=mode, parents=parents, exist_ok=exist_ok)
-        return _
-
-    def open(_, mode='r', buffering=-1, encoding=N, errors=N, newline=N):
-        return _.castToPath(
-            _._path.open(
-                mode=mode,
-                buffering=buffering,
-                encoding=encoding,
-                errors=errors,
-                newline=newline,
-            )
-        )
-
-    def owner(_):
-        return _.castToPath(_._path.owner())
-
-    def read_bytes(_):
-        return _._path.read_bytes()
-
-    def read_text(_, encoding=N, errors=N):
-        return _._path.read_text(encoding=encoding, errors=errors)
-
-    def readlink(_):
-        return _.castToPath(_._path.readlink())
-
-    def readlinkFull(_):
-        path = _._path
-        while path.is_symlink():
-            path = path.absolute()
-            path = path.readlink()
-        if not path.is_absolute():
-            path = (_._path if _._path.is_dir() else _._path.parent) / path
-        path = path.resolve()
-        return _.castToPath(path)
-
-    def relative_to(_, *other):
-        other = [x._path if isinstance(x, Dath) else x for x in other]
-        return _.clone(_._path.relative_to(*other))
-
-    def rename(_, target):
-        return _.castToPath(_._path.rename(str(target)))
-
-    move = rename
-    mv = rename
-
-    def replace(_, target):
-        return _.castToPath(_._path.replace(target))
-
-    def resolve(_, strict=F):
-        return _.castToPath(_._path.resolve(strict=strict))
-
-    def rglob(_, pattern):
-        raise NotImplementedError()
-        return _.castToPath(_._path.rglob(pattern))
-
-    def rmdir(_, logTo: callable = N):
-        if logTo:
-            logTo(f'{cl.mag}rmdir{cl.r} {cl.yel}{_._path}{cl.r}')
-        return _.castToPath(_._path.rmdir())
-
-    def samefile(_, other_path):
-        return _.castToPath(_._path.samefile(other_path))
-
-    def symlink_to(
-        _,
-        target,
-        # Ignored on unix. Required on win.
-        target_is_directory=F,
-    ):
-        target = target._path if isinstance(target, Dath) else target
-        return _.castToPath(_._path.symlink_to(target, target_is_directory=target_is_directory))
-
-    def touch(_, mode=0o600, exist_ok=T):
-        _.castToPath(_._path.touch(mode=mode, exist_ok=exist_ok))
-        return _
-
-    def unlink(_, missing_ok=F):
-        return _.castToPath(_._path.unlink(missing_ok=missing_ok))
-
-    def with_name(_, name):
-        return _.castToPath(_._path.with_name(name))
-
-    def with_stem(_, stem):
-        return _.castToPath(_._path.with_stem(stem))
-
-    def with_suffix(_, suffix):
-        return _.castToPath(_._path.with_suffix(suffix))
-
-    def write_bytes(_, data):
-        _._path.write_bytes(data)
-        return _
-
-    def write_text(_, data, encoding=N, errors=N, newline=N):
-        _._path.write_text(data)
-        return _
-
-    def __truediv__(_, arg):
-        return _.clone(_._path / str(arg))
-
-    # == camel
-    asPosix = as_posix
-    asUri = as_uri
-    hardlinkTo = hardlink_to
-    isAbsolute = is_absolute
-    isBlockDevice = is_block_device
-    isCharDevice = is_char_device
-    isDir = is_dir
-    isFifo = is_fifo
-    isFile = is_file
-    isMount = is_mount
-    isRelativeTo = is_relative_to
-    isReserved = is_reserved
-    isSocket = is_socket
-    isSymlink = is_symlink
-    linkTo = link_to
-    readBytes = read_bytes
-    readText = read_text
-    relativeTo = relative_to
-    symlinkTo = symlink_to
-    withName = with_name
-    withStem = with_stem
-    withSuffix = with_suffix
-    writeBytes = write_bytes
-    writeText = write_text
-
-    # == lower
-    asposix = as_posix
-    asuri = as_uri
-    hardlinkto = hardlink_to
-    isabsolute = is_absolute
-    isblockdevice = is_block_device
-    ischardevice = is_char_device
-    isdir = is_dir
-    isfifo = is_fifo
-    isfile = is_file
-    ismount = is_mount
-    isrelativeto = is_relative_to
-    isreserved = is_reserved
-    issocket = is_socket
-    issymlink = is_symlink
-    linkto = link_to
-    readbytes = read_bytes
-    readtext = read_text
-    relativeto = relative_to
-    symlinkto = symlink_to
-    withname = with_name
-    withstem = with_stem
-    withsuffix = with_suffix
-    writebytes = write_bytes
-    writetext = write_text
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ comparison overrides
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
+    # == comparison
     def __lt__(_, k):
-        return _._path.__lt__(_toPathlib(k))
+        return _._path.__lt__(_.__class__(k)._path)
 
     def __eq__(_, k):
-        return _._path.__eq__(_toPathlib(k))
+        # print(type(_))
+        # print(_.__slots__)
+        return _._path.__eq__(_.__class__(k)._path)
 
     def __le__(_, k):
-        return _._path.__le__(_toPathlib(k))
+        return _._path.__le__(_.__class__(k)._path)
 
     def __gt__(_, k):
-        return _._path.__gt__(_toPathlib(k))
+        return _._path.__gt__(_.__class__(k)._path)
 
     def __ge__(_, k):
-        return _._path.__ge__(_toPathlib(k))
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ Assertions
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    def assertExists(_) -> Self:
-        if not _.exists():
-            raise DathNotExistsError()
-        return _
-
-    def assertIsAbsolute(_) -> Self:
-        if not _.isAbsolute():
-            raise DathNotIsAbsoluteError()
-        return _
-
-    def assertIsBlockDevice(_) -> Self:
-        if not _.isBlockDevice():
-            raise DathNotIsBlockDeviceError()
-        return _
-
-    def assertIsCharDevice(_) -> Self:
-        if not _.isCharDevice():
-            raise DathNotIsCharDeviceError()
-        return _
-
-    def assertIsDir(_) -> Self:
-        if not _.isDir():
-            raise DathNotIsDirError()
-        return _
-
-    def assertIsFifo(_) -> Self:
-        if not _.isFifo():
-            raise DathNotIsFifoError()
-        return _
-
-    def assertIsFile(_) -> Self:
-        if not _.isFile():
-            raise DathNotIsFileError()
-        return _
-
-    def assertIsMount(_) -> Self:
-        if not _.isMount():
-            raise DathNotIsMountError()
-        return _
-
-    def assertIsRelativeTo(_) -> Self:
-        if not _.isRelativeTo():
-            raise DathNotIsRelativeToError()
-        return _
-
-    def assertIsReserved(_) -> Self:
-        if not _.isReserved():
-            raise DathNotIsReservedError()
-        return _
-
-    def assertIsSocket(_) -> Self:
-        if not _.isSocket():
-            raise DathNotIsSocketError()
-        return _
-
-    def assertIsSymlink(_) -> Self:
-        if not _.isSymlink():
-            raise DathNotIsSymlinkError()
-        return _
+        return _._path.__ge__(_.__class__(k)._path)
 
 
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-# ◼◼ DEPRICATE
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
+_PathPatch(Dath)  # | patch onto Dath to avoid IDE auto resolution
 
-
-def _toPathlib(path):  #!depricate
-    if isinstance(path, Dath):  #!depricate
-        return path._path  #!depricate
-    elif isinstance(path, str):  #!depricate
-        return pathlib.Path(path)  #!depricate
-    elif isinstance(path, pathlib.Path):  #!depricate
-        return path  #!depricate
-    else:  #!depricate
-        raise DathValueError(f'Can not cast to path {path}')  #!depricate
-
-
-def globPath(path: str | Dath) -> list[Dath]:  #!depricate
-    depricateWarning('move to  lazy class')  #!depricate
-    return [x for x in Dath(path).resolveFull()]  #!depricate
-
-
-def globPathGen(path: str | Dath) -> Iterable[Dath]:  #!depricate
-    depricateWarning('move to  lazy class')  #!depricate
-    return Dath(path).resolveFull()  #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
+#!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate #!depricate
 
 
 def currentWorkingDir():  #!depricate
diff --git a/defl/_run_.py b/defl/_run_.py
index 877ebe9..0576b75 100644
--- a/defl/_run_.py
+++ b/defl/_run_.py
@@ -306,7 +306,7 @@ class Run:
         return _
 
     # == run flow : run
-    def writeLog(_) -> Self:
+    def writeLog(_, dry: bool = F) -> Self:
         logTo = N
         logText = N
         if _.logTo is U or _.logTo is T:
@@ -319,15 +319,17 @@ class Run:
             logText = _.cmd
         if _.logText and logText:
             logText = f'{cl.grn}[{cl.r}{_.logText}{cl.grn}]{cl.r} {logText}'
+        if logText and dry:
+            logText += f' # {cl.red}DRY RUN{cl.r}'
         if logTo and logText:
             logTo(logText)
         return _
 
-    def run(_, out, err, inp: bool = F) -> Self:
+    def run(_, out, err, inp: bool = F, dry: bool = F) -> Self:
         _.assertNotRan()
         _._ran = T
 
-        _.writeLog()
+        _.writeLog(dry=dry)
 
         out = Run.pipeResolve(out)
         err = Run.pipeResolve(err)
@@ -335,7 +337,14 @@ class Run:
 
         # print({'cmd': _.cmd, 'popen': _.popenKW.args(), 'stdout': out, 'stderr': err, 'stdin': inp})
         # print(_.cmd, _.popenKW.args())
-        _._popen = Popen(_.cmd, **_.popenKW.args(), stdout=out, stderr=err, stdin=inp, **_._supressSigInt)
+        _._popen = Popen(
+            _.cmd if not dry else ['true'],  # | dry run just execute `true`
+            **_.popenKW.args(),
+            stdout=out,
+            stderr=err,
+            stdin=inp,
+            **_._supressSigInt,
+        )
 
         if out is PIPE:
             _._out = AutoReader(_._popen.stdout, threadMode=_._threadedRead)
@@ -395,15 +404,15 @@ class Run:
         if not _.success:
             errStr = '\n'.join(
                 [
-                    f'{cl.red}{_.rc}{cl.r}',
-                    f'  # {cl.yel}{_._origCmd}{cl.r}',
-                    f'  # {cl.org}{_.cmdStr.encode()}{cl.r}',
+                    f'# {cl.wht}returncode{cl.r}={cl.red}{_.rc}{cl.r}',
+                    f'# {cl.yel}{_._origCmd}{cl.r}',
+                    f'# {cl.org}{_.cmdStr.encode()}{cl.r}',
                 ]
             )
             byz = []
             byz += [x for x in _.out] if _._out and out else []
             byz += [x for x in _.err] if _._err and err else []
-            errStr += '\n' + cl.red + ((b'  | ' if byz else b'') + b'\n  | '.join(byz)).decode() + cl.r
+            errStr += '\n' + cl.red + ((b'| ' if byz else b'') + b'\n  | '.join(byz)).decode() + cl.r
             e = RunReturnCodeError(errStr)
             e.msg = byz
             raise e
@@ -411,6 +420,12 @@ class Run:
 
     assSuc = assertSuccess
 
+    def printErrIfFail(_):
+        try:
+            _.assertSuccess()
+        except RunReturnCodeError as e:
+            log.info(str(e), t='e')
+
     # | ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
     # | ◼◼ Data
     # | ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
@@ -509,6 +524,7 @@ class Run:
         _,
         sig: KillSig,  # | defl.KillSigList.SigInt
         logInfo: bool = T,
+        wait: bool = T,
     ):
         from .proc_ import Kill, KillSig  # | lazy
 
@@ -517,7 +533,7 @@ class Run:
         if _._popen.poll() is N:
             if logInfo:
                 log.info(f'{cl.red}kill{cl.r} -s {cl.mag}sig{sig}{cl.r} {cl.cyn}{_._popen.pid}{cl.r}', tgt='err')
-            Kill(signal=sig, sudo=T).kill(_._popen.pid)
+            Kill(signal=sig, sudo=T).kill(_._popen.pid, wait=wait)
         return _
 
     # == process
diff --git a/defl/_shell_.py b/defl/_shell_.py
index a64a2ab..7e3fcb1 100644
--- a/defl/_shell_.py
+++ b/defl/_shell_.py
@@ -180,6 +180,8 @@ class ShellQuote:
     # @property
     # def string(_) -> str:
     #     return str(_)
+    def toJson(_) -> str:
+        return _.cliJoin
 
 
 ShQu = ShellQuote
diff --git a/defl/_string_.py b/defl/_string_.py
index aef2946..c470142 100644
--- a/defl/_string_.py
+++ b/defl/_string_.py
@@ -45,7 +45,7 @@ def dictToStr(d: dict, k='', v='', join: str = ' ', joinItem: str = '=') -> str
     return d
 
 
-def colorDict(d: dict, k=cl.mag, v=cl.cyn, join: str = N, joinItem: str = '=') -> str | dict[str, str]:
+def colorDict(d: dict, k=cl.yel, v=cl.cyn, join: str = N, joinItem: str = '{cl.grn}=') -> str | dict[str, str]:
     return dictToStr(d=d, k=k, v=v, join=join, joinItem=joinItem)
 
 
diff --git a/defl/_thread_.py b/defl/_thread_.py
index 3da4080..1889418 100644
--- a/defl/_thread_.py
+++ b/defl/_thread_.py
@@ -99,14 +99,17 @@ class ThreadLock:
     def __post_init__(_) -> N:
         _.unlock()
 
-    def lock(_) -> N:
+    def lock(_) -> Self:
         _._ready.clear()
+        return _
 
-    def wait(_) -> N:
-        _._ready.wait(timeout=N)
+    def wait(_, timeout: int | N = N) -> Self:
+        _._ready.wait(timeout=timeout)
+        return _
 
-    def unlock(_) -> N:
+    def unlock(_) -> Self:
         _._ready.set()
+        return _
 
     def __enter__(_):
         _._ready.wait(timeout=N)
diff --git a/defl/_timeUtils_.py b/defl/_timeUtils_.py
index 0480904..0b0b1db 100644
--- a/defl/_timeUtils_.py
+++ b/defl/_timeUtils_.py
@@ -64,7 +64,7 @@ class ETA:
         percComp: float,
         secOverride: int = Undefined,  # | `Undefined` will lap the timer, `None` skips average, `int` overrides timer.lap()
     ) -> TimeDelta:
-        assert percComp <= 1 and percComp >= 0, percComp
+        # assert percComp <= 1 and percComp >= 0, percComp
         percComp = 0.000001 if percComp == 0 else percComp
         if _.timer is not None and secOverride is not None:
             _.rollAvg.add(_.timer.lap().seconds if secOverride is Undefined else secOverride)
@@ -98,6 +98,8 @@ class ProgressPrint:
     def __post_init__(_):
         if isinstance(_.completeAmt, Collection):
             _.completeAmt = len(_.completeAmt)
+        if not _.eta:
+            _.eta = N
 
     def inc(
         _,
diff --git a/defl/_time_.py b/defl/_time_.py
index 8d72f6b..1a13cf3 100644
--- a/defl/_time_.py
+++ b/defl/_time_.py
@@ -319,6 +319,7 @@ class TimeFormat(Enumer):
     time = '%H:%M:%S'
     pretty = '%a %d %b %y %H:%M:%S'
     prettyDay = '%a %d %b %y'
+    ymdhmsfDash = '%Y-%m-%d-%H-%M-%S-%f'
 
 
 @dataclass(slots=True, kw_only=False, frozen=False)
@@ -330,7 +331,12 @@ class Time:
     LocalTz: ClassVar = TimeZone(TimeZone.localOffset())
     tz: TimeZone = Undefined
     autoAddTzStr: bool = True  # only effects __str__
+    TZ: ClassVar[Type] = TimeZone
+    TD: ClassVar[Type] = TimeDelta
+    TU: ClassVar[Type] = TimeUnit
 
+    # TODO when getting dt the timezone is TimeZone and not timezone.utc type  date = date.replace(tzinfo=timezone.utc)
+    # TODO       so dataframes fail on TimeZone type
     Fmt = TimeFormat
 
     __add__ = Obj.__add__
diff --git a/defl/fileTypes_.py b/defl/fileTypes_.py
new file mode 100755
index 0000000..b47bdd9
--- /dev/null
+++ b/defl/fileTypes_.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+
+from collections import Counter
+import sys, re, os, enum, itertools
+from functools import partial, partialmethod
+from time import sleep
+from dataclasses import dataclass, field
+from operator import itemgetter
+from defl import log, cl, Dath, Time, Run, sp
+from defl._typing_ import *
+from defl._typing_ import T, F, N, U
+from defl._rich_ import *
+from defl._pydantic_ import *
+import defl
+
+
+class Type(defl.Enumer):
+    Video = enum.auto()
+    Audio = enum.auto()
+    Text = enum.auto()
+    Dir = enum.auto()
+
+
+fileTypeToExt = {
+    Type.Video: [
+        'mp4',
+        'avi',
+        'mkv',
+        'mov',
+        'wmv',
+        'm4v',
+        'gif',
+        '3g2',
+        'mpg',
+        '3gpp',
+        'mod',
+        'mov',
+        '3gp',
+        'rmvb',
+        'm2ts',
+        'webm',
+        'mts',
+    ],
+    Type.Audio: [
+        'mp3',
+        'flac',
+        'm4a',
+        'wav',
+        'webm',
+        'aiff',
+        'wma',
+        'opus',
+        'aac',
+    ],
+    Type.Text: [
+        'log',
+        'sh',
+        'txt',
+        'md',
+    ],
+}
+
+
+@dataclass(slots=T, kw_only=T)
+class FileType:
+    def ext(_, path: Dath) -> list[Type]:
+        if path.isDir():
+            return [Type.Dir]
+        ext = path.suffix.strip('.').lower()
+        match = [k for k, v in fileTypeToExt.items() if ext in v]
+        if defl.amCliEntryPoint():
+            log.info(' '.join(match))
+        return match
+
+    def exts(_, *paths: Dath) -> dict[Dath, list[Type]]:
+        res = {x: _.ext(x) for x in paths}
+        if defl.amCliEntryPoint():
+            log.info(lambda jc: res)
+        return res
+
+    def isType(_, path: Dath, typ: Type, only: bool = F) -> bool:
+        if only:
+            r = _.ext(path=path) == [typ]
+        else:
+            r = typ in _.ext(path=path)
+        if defl.amCliEntryPoint():
+            sys.exit(0 if r else 1)
+        return r
+
+    def isVideo(_, path: Dath, only: bool = F) -> bool:
+        r = _.isType(typ=Type.Video, path=path, only=only)
+        if defl.amCliEntryPoint():
+            sys.exit(0 if r else 1)
+        return r
+
+    def isAudio(_, path: Dath, only: bool = F) -> bool:
+        r = _.isType(typ=Type.Audio, path=path, only=only)
+        if defl.amCliEntryPoint():
+            sys.exit(0 if r else 1)
+        return r
+
+    def isText(_, path: Dath, only: bool = F) -> bool:
+        r = _.isType(typ=Type.Text, path=path, only=only)
+        if defl.amCliEntryPoint():
+            sys.exit(0 if r else 1)
+        return r
+
+
+# TODO make cli file in bashtools
+# if __name__ == '__main__':
+#     with defl.suppressStackTraceCM(defl.ArgFromObjError):
+#         defl.ParseObj(CLI, mapSubParsers={'-': 'ext'}).parse(sys.argv[1:])
diff --git a/defl/lsblk_.py b/defl/lsblk_.py
index 62ef0a1..8596367 100644
--- a/defl/lsblk_.py
+++ b/defl/lsblk_.py
@@ -4,8 +4,9 @@
 # ` udevadm info --query=all --name=/dev/sdb
 
 from dataclasses import dataclass, field
+import dataclasses
 
-from defl import Path, Obj, Run, Dath
+from defl import Path, Obj, Run, Dath, log
 from defl._typing_ import *
 import defl
 from defl._pydantic_ import *
@@ -14,15 +15,15 @@ from defl._pydantic_ import *
 @dataclass(slots=T, kw_only=T, frozen=F)
 class DiskTree:
     root: Path | N
-    byId: N | list[Path] = N
-    byPath: N | list[Path] = N
-    byDiskseq: N | list[Path] = N
-    byPartlabel: N | list[Path] = N
-    byUuid: N | list[Path] = N
-    byPartuuid: N | list[Path] = N
-    byLoopInode: N | list[Path] = N
-    byLoopRef: N | list[Path] = N
-    byLabel: N | list[Path] = N
+    byId: N | list[Path] = field(default_factory=list)
+    byPath: N | list[Path] = field(default_factory=list)
+    byDiskseq: N | list[Path] = field(default_factory=list)
+    byPartlabel: N | list[Path] = field(default_factory=list)
+    byUuid: N | list[Path] = field(default_factory=list)
+    byPartuuid: N | list[Path] = field(default_factory=list)
+    byLoopInode: N | list[Path] = field(default_factory=list)
+    byLoopRef: N | list[Path] = field(default_factory=list)
+    byLabel: N | list[Path] = field(default_factory=list)
 
     def has(_, path: Path):
         assert inst(path, Path)
@@ -48,206 +49,213 @@ class DiskTree:
                 if a.isEmptyLeaf(res, name):
                     a[res, name] = []
                 a[res, name].append(path)
-        return {k: DiskTree(root=k, **v) for k, v in a.items()}
+        return {k: DiskTree(root=k, **v) for k, v in a.data.items()}
 
     toJson = Obj.toJson
 
 
+LsblkCollection = TypeVar('LsblkCollection')
+Lsblk = TypeVar('Lsblk')
+
+
 @dataclass(slots=T, kw_only=T, frozen=F)
 class Lsblk:
+    _diskTree: DiskTree | N = N
+    _meta: dict = field(default_factory=dict, kw_only=T, repr=T)
+    _keep: bool = T  # | hidden attribute which filters out items when descending
+    _parent: Self | N = N
+
+    @property
+    def parent(_) -> Self:
+        return _._parent
+
     def toJson(_, keys: list | str = None) -> dict:
         if not keys:
-            keys = ['path', 'typee', 'mountpoint', 'fstype', 'children']
-        elif keys[0] == 'all':
+            keys = ['path', 'typee', 'mountpoint', 'fstype']
+        elif keys[0] == 'all' or keys == 'all':
             keys = _.__slots__
-        d = {k: getattr(_, k) for k in keys}
-        if 'children' in d:
-            d['children'] = [x.toJson(keys=keys) for x in d['children']]
-        return d
+        keep = ['_keep'] if not _._keep and '_keep' not in keys else []
+        return {k: _[k] for k in keys + keep}
+
+    @classmethod
+    def FromData(cls, data: dict) -> Self:
+        assert inst(data, dict)
+        data['path'] = Path(data['path'])
+        data['fsroots'] = [x for x in data['fsroots'] if x]
+        data['mountpoints'] = [x for x in data['mountpoints'] if x]
+        children = data.get('children', [])
+        data['children'] = []
+        data = {k: data[v] for k, v in cls.Translation.items()}
+        parent = cls(**data)
+        children = [cls.FromData(data=x) for x in children]
+        for child in children:
+            child._parent = parent
+        parent.children = children
+        return parent
 
     def __str__(_) -> str:
         return str(_.toJson())
 
-    @classmethod
-    def Run(cls, *devs) -> 'LsblkCollection':
-        return LsblkCollection(devs=devs)
-
     def __iter__(_) -> defl.Generator[Self, N, N]:
         yield _
         for i in _.children:
             yield i
 
-    # == repr
-    path: Path = field(repr=T)
-    typee: str = field(repr=T)
-    mountpoint: str | N = field(repr=T)
-    fstype: str | N = field(repr=T)
-    children: list[Self] = field(repr=T)
+    def __getitem__(_, k):
+        if inst(k, list | tuple):
+            return _.toJson(keys=k)
+        if hasattr(_, k):
+            return getattr(_, k)
+        elif k in Lsblk.TranslationBackwords:
+            return getattr(_, Lsblk.TranslationBackwords[k])
+        elif k in _._meta:
+            return _._meta[k]
+        getattr(_, k)  # | raise AttributeError()
+        raise NotImplementedError('dont get here')
 
-    # == default
-    name: str = field(repr=F)
-    alignment: int = field(repr=F)
-    idLink: str | N = field(repr=F)
-    idd: str | N = field(repr=F)
-    discAln: int = field(repr=F)
-    dax: bool = field(repr=F)
-    discGran: str = field(repr=F)
-    diskSeq: int = field(repr=F)
-    discMax: str = field(repr=F)
-    discZero: bool = field(repr=F)
-    fsavail: str | N = field(repr=F)
-    fsroots: list = field(repr=F)
-    fssize: str | N = field(repr=F)
-    fsused: str | N = field(repr=F)
-    fsusePerc: str | N = field(repr=F)
-    fsver: str | N = field(repr=F)
-    group: str = field(repr=F)
-    hctl: str | N = field(repr=F)
-    hotplug: bool = field(repr=F)
-    kname: str = field(repr=F)
-    label: str | N = field(repr=F)
-    logSec: int = field(repr=F)
-    majMin: str = field(repr=F)
-    maj: str = field(repr=F)
-    minn: str = field(repr=F)
-    minIo: int = field(repr=F)
-    mode: str = field(repr=F)
-    model: str | N = field(repr=F)
-    mq: str = field(repr=F)
-    optIo: int = field(repr=F)
-    owner: str = field(repr=F)
-    partflags: str | N = field(repr=F)
-    partlabel: str | N = field(repr=F)
-    partn: int | N = field(repr=F)
-    parttype: str | N = field(repr=F)
-    parttypename: str | N = field(repr=F)
-    partuuid: str | N = field(repr=F)
-    phySec: int = field(repr=F)
-    pkname: str | N = field(repr=F)
-    pttype: str | N = field(repr=F)
-    ptuuid: str | N = field(repr=F)
-    ra: int = field(repr=F)
-    rand: bool = field(repr=F)
-    rev: str | N = field(repr=F)
-    rm: bool = field(repr=F)
-    ro: bool = field(repr=F)
-    rota: bool = field(repr=F)
-    rqSize: int | N = field(repr=F)
-    sched: str | N = field(repr=F)
-    serial: str | N = field(repr=F)
-    size: str = field(repr=F)
-    start: int | N = field(repr=F)
-    state: str | N = field(repr=F)
-    subsystems: str = field(repr=F)
-    mountpoints: list = field(repr=F)
-    tran: str | N = field(repr=F)
-    uuid: str | N = field(repr=F)
-    vendor: str | N = field(repr=F)
-    wsame: str = field(repr=F)
-    wwn: str | N = field(repr=F)
-    zoned: str = field(repr=F)
-    zoneSz: str = field(repr=F)
-    zoneWgran: str = field(repr=F)
-    zoneApp: str = field(repr=F)
-    zoneNr: int = field(repr=F)
-    zoneOmax: int = field(repr=F)
-    zoneAmax: int = field(repr=F)
+    def lineage(_) -> Generator[Self, N, N]:
+        parent = _
+        while parent:
+            yield parent
+            parent = parent.parent
 
-    # == cast data
-    translation: ClassVar[dict[str, str]] = {
-        'alignment': 'alignment',
-        'idLink': 'id-link',
-        'idd': 'id',
-        'discAln': 'disc-aln',
-        'dax': 'dax',
-        'discGran': 'disc-gran',
-        'diskSeq': 'disk-seq',
-        'discMax': 'disc-max',
-        'discZero': 'disc-zero',
-        'fsavail': 'fsavail',
-        'fsroots': 'fsroots',
-        'fssize': 'fssize',
-        'fstype': 'fstype',
-        'fsused': 'fsused',
-        'fsusePerc': 'fsuse%',
-        'fsver': 'fsver',
-        'group': 'group',
-        'hctl': 'hctl',
-        'hotplug': 'hotplug',
-        'kname': 'kname',
-        'label': 'label',
-        'logSec': 'log-sec',
-        'majMin': 'maj:min',
-        'maj': 'maj',
-        'minn': 'min',
-        'minIo': 'min-io',
-        'mode': 'mode',
-        'model': 'model',
-        'mq': 'mq',
-        'name': 'name',
-        'optIo': 'opt-io',
-        'owner': 'owner',
-        'partflags': 'partflags',
-        'partlabel': 'partlabel',
-        'partn': 'partn',
-        'parttype': 'parttype',
-        'parttypename': 'parttypename',
-        'partuuid': 'partuuid',
-        'path': 'path',
-        'phySec': 'phy-sec',
-        'pkname': 'pkname',
-        'pttype': 'pttype',
-        'ptuuid': 'ptuuid',
-        'ra': 'ra',
-        'rand': 'rand',
-        'rev': 'rev',
-        'rm': 'rm',
-        'ro': 'ro',
-        'rota': 'rota',
-        'rqSize': 'rq-size',
-        'sched': 'sched',
-        'serial': 'serial',
-        'size': 'size',
-        'start': 'start',
-        'state': 'state',
-        'subsystems': 'subsystems',
-        'mountpoint': 'mountpoint',
-        'mountpoints': 'mountpoints',
-        'tran': 'tran',
-        'typee': 'type',
-        'uuid': 'uuid',
-        'vendor': 'vendor',
-        'wsame': 'wsame',
-        'wwn': 'wwn',
-        'zoned': 'zoned',
-        'zoneSz': 'zone-sz',
-        'zoneWgran': 'zone-wgran',
-        'zoneApp': 'zone-app',
-        'zoneNr': 'zone-nr',
-        'zoneOmax': 'zone-omax',
-        'zoneAmax': 'zone-amax',
-        'children': 'children',
-    }
+    alignment: int = field(repr=F, metadata={'translation': 'alignment'})
+    children: list[Self] = field(repr=T, metadata={'translation': 'children'})
+    dax: bool = field(repr=F, metadata={'translation': 'dax'})
+    discAln: int = field(repr=F, metadata={'translation': 'disc-aln'})
+    discGran: str = field(repr=F, metadata={'translation': 'disc-gran'})
+    discMax: str = field(repr=F, metadata={'translation': 'disc-max'})
+    discZero: bool = field(repr=F, metadata={'translation': 'disc-zero'})
+    diskSeq: int = field(repr=F, metadata={'translation': 'disk-seq'})
+    fsavail: str | N = field(repr=F, metadata={'translation': 'fsavail'})
+    fsroots: list = field(repr=F, metadata={'translation': 'fsroots'})
+    fssize: str | N = field(repr=F, metadata={'translation': 'fssize'})
+    fstype: str | N = field(repr=T, metadata={'translation': 'fstype'})
+    fsused: str | N = field(repr=F, metadata={'translation': 'fsused'})
+    fsusePerc: str | N = field(repr=F, metadata={'translation': 'fsuse%'})
+    fsver: str | N = field(repr=F, metadata={'translation': 'fsver'})
+    group: str = field(repr=F, metadata={'translation': 'group'})
+    hctl: str | N = field(repr=F, metadata={'translation': 'hctl'})
+    hotplug: bool = field(repr=F, metadata={'translation': 'hotplug'})
+    idd: str | N = field(repr=F, metadata={'translation': 'id'})
+    idLink: str | N = field(repr=F, metadata={'translation': 'id-link'})
+    kname: str = field(repr=F, metadata={'translation': 'kname'})
+    label: str | N = field(repr=F, metadata={'translation': 'label'})
+    logSec: int = field(repr=F, metadata={'translation': 'log-sec'})
+    majMin: str = field(repr=F, metadata={'translation': 'maj'})
+    maj: str = field(repr=F, metadata={'translation': 'maj:min'})
+    minIo: int = field(repr=F, metadata={'translation': 'min-io'})
+    minn: str = field(repr=F, metadata={'translation': 'min'})
+    model: str | N = field(repr=F, metadata={'translation': 'model'})
+    mode: str = field(repr=F, metadata={'translation': 'mode'})
+    mountpoints: list = field(repr=F, metadata={'translation': 'mountpoints'})
+    mountpoint: str | N = field(repr=T, metadata={'translation': 'mountpoint'})
+    mq: str = field(repr=F, metadata={'translation': 'mq'})
+    name: str = field(repr=F, metadata={'translation': 'name'})
+    optIo: int = field(repr=F, metadata={'translation': 'opt-io'})
+    owner: str = field(repr=F, metadata={'translation': 'owner'})
+    partflags: str | N = field(repr=F, metadata={'translation': 'partflags'})
+    partlabel: str | N = field(repr=F, metadata={'translation': 'partlabel'})
+    partn: int | N = field(repr=F, metadata={'translation': 'partn'})
+    parttypename: str | N = field(repr=F, metadata={'translation': 'parttypename'})
+    parttype: str | N = field(repr=F, metadata={'translation': 'parttype'})
+    partuuid: str | N = field(repr=F, metadata={'translation': 'partuuid'})
+    path: Path = field(repr=T, metadata={'translation': 'path'})
+    phySec: int = field(repr=F, metadata={'translation': 'phy-sec'})
+    pkname: str | N = field(repr=F, metadata={'translation': 'pkname'})
+    pttype: str | N = field(repr=F, metadata={'translation': 'pttype'})
+    ptuuid: str | N = field(repr=F, metadata={'translation': 'ptuuid'})
+    ra: int = field(repr=F, metadata={'translation': 'ra'})
+    rand: bool = field(repr=F, metadata={'translation': 'rand'})
+    rev: str | N = field(repr=F, metadata={'translation': 'rev'})
+    rm: bool = field(repr=F, metadata={'translation': 'rm'})
+    ro: bool = field(repr=F, metadata={'translation': 'ro'})
+    rota: bool = field(repr=F, metadata={'translation': 'rota'})
+    rqSize: int | N = field(repr=F, metadata={'translation': 'rq-size'})
+    sched: str | N = field(repr=F, metadata={'translation': 'sched'})
+    serial: str | N = field(repr=F, metadata={'translation': 'serial'})
+    size: str = field(repr=F, metadata={'translation': 'size'})
+    start: int | N = field(repr=F, metadata={'translation': 'start'})
+    state: str | N = field(repr=F, metadata={'translation': 'state'})
+    subsystems: str = field(repr=F, metadata={'translation': 'subsystems'})
+    tran: str | N = field(repr=F, metadata={'translation': 'tran'})
+    typee: str = field(repr=T, metadata={'translation': 'type'})
+    uuid: str | N = field(repr=F, metadata={'translation': 'uuid'})
+    vendor: str | N = field(repr=F, metadata={'translation': 'vendor'})
+    wsame: str = field(repr=F, metadata={'translation': 'wsame'})
+    wwn: str | N = field(repr=F, metadata={'translation': 'wwn'})
+    zoneAmax: int = field(repr=F, metadata={'translation': 'zone-amax'})
+    zoneApp: str = field(repr=F, metadata={'translation': 'zone-app'})
+    zoned: str = field(repr=F, metadata={'translation': 'zoned'})
+    zoneNr: int = field(repr=F, metadata={'translation': 'zone-nr'})
+    zoneOmax: int = field(repr=F, metadata={'translation': 'zone-omax'})
+    zoneSz: str = field(repr=F, metadata={'translation': 'zone-sz'})
+    zoneWgran: str = field(repr=F, metadata={'translation': 'zone-wgran'})
 
-    diskTree: DiskTree | N
+
+Lsblk.Translation: ClassVar[dict[str, str]] = {
+    x.name: x.metadata['translation'] for x in dataclasses.fields(Lsblk) if not x.name.startswith('_')
+}
+Lsblk.TranslationBackwords: ClassVar[dict[str, str]] = {v: k for k, v in Lsblk.Translation.items()}
 
 
 @dataclass(slots=T, kw_only=T, frozen=F)
 class LsblkCollection:
-    devs: list[str] = field(default_factory=list, kw_only=F, repr=T)
-    # TODO make iterable
-    lsblks: list[Lsblk] = None
-    diskTree: dict[Path, DiskTree] = None
+    _data: list[Lsblk]
 
-    def __post_init__(_):
-        cmd = ['lsblk', '-J', '-O', *_.devs]
-        data = Run(cmd).run(T, T).wait().assSuc().json()['blockdevices']
-        _.diskTree = DiskTree.Run()
-        _.lsblks = _._fromData(data)
+    @staticmethod
+    def Command(*dev):
+        if len(dev) == 1 and inst(dev, list | tuple):
+            dev = dev[0]
+        return ['lsblk', '--json', '--output-all', *dev]
+
+    @classmethod
+    def FromRun(cls, *devs) -> Self:
+        cmd = devs
+        data = Run(cmd).run(T, T).wait().assSuc().json()
+        return cls.FromData(data=data)
+
+    @classmethod
+    def FromData(cls, data: list[dict]) -> Self:
+        if 'blockdevices' in data:
+            data = data['blockdevices']
+        assert inst(data, list | tuple)
+        return cls(_data=[Lsblk.FromData(data=x) for x in data])
+
+    _diskTree: DiskTree | type(...) = field(default=..., repr=F)  # | property not set
+
+    @property
+    def dt(_) -> DiskTree:
+        return _.diskTree
+
+    @property
+    def diskTree(_) -> DiskTree:
+        # | use cache property incase lsblk is from data like using ssh
+        if _._diskTree is ...:
+            _._diskTree = _._diskTreeGet()
+        return _._diskTree
+
+    def _diskTreeGet(_) -> DiskTree:
+        diskTree = DiskTree.Run()
+        _.populateDiskLinks(diskTree=diskTree)
+        return diskTree
+
+    def populateDiskLinks(_, diskTree: DiskTree = N) -> Self:
+        if not diskTree:
+            diskTree = DiskTree.Run()
+        dtName = {k.name: v for k, v in diskTree.items()}
+        for lsblk in _.toList():
+            if res := diskTree.get(lsblk.path):
+                lsblk._diskTree = res
+            elif res := dtName.get(lsblk.kname):  # | i.e. "dm-2"
+                lsblk._diskTree = res
+            # else:
+            #     print(lsblk.path)
+        return _
 
     def toList(_, _items: list[Self] | Self = None) -> Generator[Any | Self, Any, None]:
         if _items is None:
-            _items = _.lsblks
+            _items = _._data
         if inst(_items, list):
             for i in _items:
                 for j in _.toList(i):
@@ -260,7 +268,12 @@ class LsblkCollection:
             else:
                 yield _items
 
-    def filter(_, match: Callable, /, _items: list[Self] | Self = None) -> Generator[Any | Self, Any, None]:
+    def filter(
+        _,
+        match: Callable,
+        /,
+        _items: list[Self] | Self = None,
+    ) -> Generator[Any | Self, Any, None]:
         for i in _.toList():
             if match(i):
                 yield i
@@ -280,25 +293,94 @@ class LsblkCollection:
             raise ValueError(f'Results length {l} > 1')
         return res[0]
 
-    def _fromData(_, data: list | dict) -> list[Lsblk]:
-        if inst(data, list):
-            data = [_._fromData(x) for x in data]
-        elif inst(data, dict):
-            data['path'] = Path(data['path'])
-            data['fsroots'] = [x for x in data['fsroots'] if x]
-            data['mountpoints'] = [x for x in data['mountpoints'] if x]
-
-            data['children'] = _._fromData(data['children']) if data.get('children') else []
-            data = Lsblk(
-                **{k: data[v] for k, v in Lsblk.translation.items()},
-                diskTree=_.diskTree.get(data['path'], DiskTree(root=None)),
-            )
-        return data
+    def getAssOne(_) -> Lsblk:
+        assert len(_._data) == 1
+        return _._data[0]
 
     def __iter__(_) -> defl.Generator[Lsblk, N, N]:
-        for i in _.lsblks:
+        for i in _._data:
             yield i
 
+    def __getitem__(_, k):
+        if not inst(k, tuple | list):
+            k = [k]
+        # if 'children' not in k:
+        #     k.append('children')
+        return _.descendDict(lambda x: x[k])
+
+    def descend(
+        _,
+        process: Callable | dict[Any, Callable],
+        _lsblk: Any = N,
+        _i: int = 0,
+    ) -> Self:
+        # TODO depth first breadth first
+        # == iterate
+        if _lsblk is N:
+            desc = _.descend(process=process, _lsblk=_._data, _i=_i + 1)
+            desc = [x for x in desc if x]
+            return _.__class__(_data=desc)
+
+        if inst(_lsblk, list):
+            res = [_.descend(process=process, _lsblk=x, _i=_i + 1) for x in _lsblk]
+            res = [x for x in res if x and x._keep]
+            return res
+
+        _lsblk.children = _.descend(process=process, _lsblk=_lsblk.children, _i=_i + 1)
+
+        # == evaluate
+        res = _._applyDictCallable(process=process, value=_lsblk)
+
+        # == result
+        if callable(process):
+            res = {'result': res}
+        _lsblk._meta.update(res)
+        # print(_lsblk.name, res, _lsblk._meta)
+        # print('  ' * _i, process.keys() if inst(process,dict) else process, _lsblk.name, 'keep', _lsblk._keep, 'result', _lsblk._meta)
+        if _lsblk._keep:
+            return _lsblk
+
+    def descendDict(
+        _,
+        process: Callable | dict[Any, Callable],
+        dropNone: bool = F,
+        _lsblk: Any = N,
+        _tmpKey: Any = N,
+    ) -> Self:
+        if _lsblk is N:
+            _tmpKey = defl.randomString()
+            _.descend(process={_tmpKey: partial(_._applyDictCallable, process=process)})
+            desc = _.descendDict(process=N, _lsblk=_._data, _tmpKey=_tmpKey, dropNone=dropNone)
+            desc = [x for x in desc if x]
+            return desc
+        elif inst(_lsblk, list):
+            desc = [_.descendDict(process=N, _lsblk=x, _tmpKey=_tmpKey, dropNone=dropNone) for x in _lsblk]
+            desc = [x for x in desc if x]
+            return desc
+
+        res = _lsblk._meta[_tmpKey]
+        del _lsblk._meta[_tmpKey]
+
+        children = [_.descendDict(process=N, _lsblk=x, _tmpKey=_tmpKey, dropNone=dropNone) for x in _lsblk.children]
+        if dropNone:
+            children = [x for x in children if x]
+
+        if _lsblk._keep:
+            if dropNone and not res:
+                return
+            return {'result': res} | {'children': children}
+
+    @staticmethod
+    def _applyDictCallable(value: Any, process: Callable | dict[Any, Callable]):
+        if callable(process):
+            return process(value)
+        else:
+            assert 'children' not in process
+            return {k: v(value) for k, v in process.items()}
+
+    def toJson(_, keys: list = N):
+        return _.descendDict(process=lambda x: x[['name', 'type', 'mountpoints']])
+
 
 @dataclass(slots=T, kw_only=T, frozen=F)
 class LoopDev:
@@ -365,7 +447,7 @@ class LoopDev:
         return dev
 
 
-@dantDC()
+@dataclass(slots=T, kw_only=T, frozen=F)
 class _MountPoint:
     device: Dath
     mount: Dath
@@ -374,9 +456,9 @@ class _MountPoint:
 
 
 # TODO use /proc/mount
-@dantDC()
+@dataclass(slots=T, kw_only=T, frozen=F)
 class MountPoints:
-    _mounts: list[_MountPoint] = DantField([], kw_only=T, repr=T)
+    _mounts: list[_MountPoint] = field(default_factory=list, kw_only=T, repr=T)
 
     def __post_init__(_) -> N:
         mntPath = Dath('/proc/mounts')
@@ -397,6 +479,7 @@ class MountPoints:
         def f(x: _MountPoint):
             if dev and x.device != dev:
                 return
+            # print(type(x.mount._path), type(mnt))
             if mnt and x.mount != mnt:
                 return
             if fs and x.fs != fs:
diff --git a/defl/mpv2_.py b/defl/mpv2_.py
index 4bf8344..7a8c7c1 100644
--- a/defl/mpv2_.py
+++ b/defl/mpv2_.py
@@ -1,486 +1,553 @@
-#!/usr/bin/env python
-
-# TODO subtitiles
-"""
-# https://github.com/jaseg/python-mpv/blob/main/mpv.py
-"""
-
-from dataclasses import dataclass, field
-import re, threading
-import os
-import enum
-import json
-import atexit
-import socket
-from time import sleep
-from defl import (
-    cl,
-    log,
-    Dath,
-    Run,
-)
-from defl._typing_ import *
-from contextlib import contextmanager
-from defl._typing_ import T, F, N, U
-from defl._rich_ import *
-from defl.mpv2_ import *
-import defl
-
-
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-# ◼◼ Mpv Log Classes
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class MpvEvent:
-    event: str
-    reason: str | UT = U
-    file_error: str | UT = U
-    playlist_entry_id: int | UT = U
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class MpvRequest:
-    data: Any | UT = U
-    error: str
-
-    def success(_) -> bool:
-        return _.error == 'success'
-
-    def assSuc(_):
-        assert _.success(), _
-
-
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-# ◼◼ exceptions
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-
-class MpvError(Exception):
-    __slot__ = ()
-
-
-class MpvSocketExistsError(MpvError):
-    __slot__ = ()
-
-
-class MpvRunningError(MpvError):
-    __slot__ = ()
-
-
-class MpvNoSocketFileError(MpvError):
-    __slot__ = ()
-
-
-class MpvNotRunningError(MpvError):
-    __slot__ = ()
-
-
-class MpvFailedToStartVideo(MpvError):
-    __slot__ = ()
-
-
-class MpvEventsChangedOnIter(MpvError, IndexError):
-    __slot__ = ()
-
-
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-# ◼◼ Enum
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-
-class MpvFailReason(defl.Enumer):
-    AgeRestricted = enum.auto()
-    Forbidden403 = enum.auto()
-
-
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-# ◼◼ MPV
-# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class Mpv:
-    _tmpPath: Dath = N
-    _run: Run | UT = U
-    _socket: socket.socket | UT = U
-    _events: list[MpvEvent] = field(default_factory=list, kw_only=T, repr=F)
-    _request: dict[int, MpvRequest] = field(default_factory=dict, kw_only=T, repr=F)
-    _running: bool = F
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ printing
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    def richAutoReprSuper(_):
-        yield 'running', _._running
-
-    __rich_repr__ = defl.Obj.richAutoRepr
-    __str__ = defl.Obj.toRichRepr
-    __repr__ = defl.Obj.toRichRepr
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ properies
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    @property
-    def running(_) -> bool:
-        return _._running
-
-    @property
-    def sockPath(_) -> Dath:
-        return _._tmpPath.reExt('sock')
-
-    @property
-    def logPath(_) -> Dath:
-        return _._tmpPath.reExt('log')
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ init
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    def __post_init__(_) -> N:
-        _._tmpPath = Dath.Temp().temp(create=F)
-        # _.logPath.rmOnExit()
-
-    def run(_) -> Run:
-        if _.sockPath.exists():
-            raise MpvSocketExistsError()
-        if _._run is not U and _._run.rc is N:
-            raise MpvRunningError()
-        if _._running:
-            raise MpvRunningError()
-        _._running = T
-        _._run = Run(_.cmd).run(N, N)
-        _._socket = _.connectToSocket()
-        atexit.register(_.exit)
-        return _._run
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ CLI
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    _ydlQuality: str = 'worst[height>=320]/worst/worstaudio+worstvideo'
-
-    def ydlQualityGS(_, val: str = U) -> str:
-        if val is not U:
-            _._ydlQuality = val
-        return _._ydlQuality
-
-    _extraMpvOpt: list[str] = field(default_factory=list, kw_only=T, repr=T)
-
-    def extraMpvOptGS(_, *args: str, **kargs) -> list[str]:
-        _._extraMpvOpt.extend(args)
-        assert inst(_._extraMpvOpt, list)
-        return _._extraMpvOpt
-
-    @property
-    def cmd(_) -> list[str]:
-        empty = '/tmp/empty.mp4'  # | have to have a file to start
-        s = 'anullsrc=r=44100:cl=mono'
-        cmd = ['ffmpeg', '-y', '-t', 0.1, '-s']
-        cmd += ['640x480', '-f', 'rawvideo', '-pix_fmt', 'rgb24', '-r', '25', '-i', '/dev/zero', empty]
-        # cmd = ['ffmpeg', '-y', '-f', 'lavfi', '-i', s, '-t', '0.1', '-q:a', '9', '-acodec', 'libmp3lame', empty]
-        Run(cmd).run(T, T).assSuc()
-
-        home = os.environ['HOME']
-        ytOpt = [
-            f'--script-opts=ytdl_hook-ytdl_path={home}/.local/bin/yt-dlp',
-            f'--ytdl-format={_.ydlQualityGS()}',
-            '--ytdl-raw-options=no-playlist=',
-        ]
-        mpvOpt = [
-            # '--track-auto-selection=no',
-            '--fullscreen=yes',
-            f'--input-ipc-server={_.sockPath}',
-            '--keep-open=always',
-            '--msg-level=all=error',
-            f'--log-file={_.logPath}',
-            '--idle=yes',
-        ]
-        return ['mpv', *mpvOpt, *ytOpt, *_.extraMpvOptGS(), '--', empty]
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ socket communication
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    def connectToSocket(_) -> socket.socket:
-        i = 0
-        while not _.sockPath.exists():
-            i += 1
-            sleep(0.2)
-            log.info(f'wait for socket ({i})', _.sockPath, end=cl.startOfLine)
-            _.verifyMpvRunning()
-
-        retry = T
-        while retry:
-            with defl.IgnoreExceptionCM(ConnectionError):
-                sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-                sock.connect(_.sockPath.s)
-                sock.settimeout(0.2)
-                retry = F
-
-        return sock
-
-    _sendCmdId: int = 0
-
-    def sendCmd(_, *cmd) -> MpvRequest:
-        if len(cmd) == 1 and inst(cmd[0], list):
-            cmd = cmd[0]
-
-        if not _.sockPath.exists():
-            raise MpvNoSocketFileError()
-
-        idd = _._sendCmdId
-        log.debug(f'send cmd {idd}', lambda x: x.cmd)
-        _._sendCmdId = (_._sendCmdId + 1) % 99999
-        data = {'command': cmd, 'request_id': idd}
-        cmd = json.dumps(data).encode('utf8') + b'\n'
-        with _.useSocketCM():
-            _._socket.send(cmd)
-
-        while idd not in _._request:
-            # TODO optimize
-            _._addLinesToCache()
-            sleep(0.05)
-        res = _._request.pop(idd)
-        log.debug(f'  -> cmd result {idd}', lambda x: x.res)
-
-        return res
-
-    @contextmanager
-    def useSocketCM(_):
-        try:
-            if _._socket is U:
-                _.verifyMpvRunning()
-            yield
-        except BrokenPipeError as e:
-            _.closeSocket()
-            _.exit()
-            _.verifyMpvRunning()
-            raise e
-        except TimeoutError:
-            ...  # | ignore
-
-    def closeSocket(_) -> Self:
-        if _._socket is not U:
-            _._socket.close()
-        _._socket = U
-        return _
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ controls
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    def verifyMpvRunning(_) -> Self:
-        if _._run.rc is not N:
-            raise MpvNotRunningError(f'{_._run.rc} {_.logPath}')
-        return _
-
-    def exit(_) -> Self:
-        if not _._running:
-            return _
-        atexit.unregister(_.exit)
-        log.info('quit mpv', '')
-        if _._socket is not U:
-            try:
-                _.quitMpv()
-            except MpvNotRunningError:
-                log.info('Already exited', '')
-        _.closeSocket()
-        _.sockPath.remove()
-        _._run.kill('int')
-        assert _._run.rc is not N
-        _._running = F
-        return _
-
-    def steamStartVideo(_, source: str) -> Generator[MpvEvent | N, N, N]:
-        oldDur = _.duration()
-        playListId = _.loadSource(source)
-
-        events = _.eventIter()
-
-        i = 0
-        while (duration := _.duration()) is N or duration == oldDur:
-            if i % 10 == 0:
-                _.verifyMpvRunning()
-                if _.idleActive():
-                    # TODO video display dissapears so next video fails.
-                    raise MpvFailedToStartVideo(_.logPath)
-            i += 1
-            log.debug('waiting for video to load')
-            sleep(0.2)
-            while (event := next(events)) is not N:
-                log.info('event', lambda x: x.event)
-                if event.event == 'end-file':
-                    if event.playlist_entry_id == playListId:
-                        raise MpvFailedToStartVideo(event)
-
-        while (t := _.curTime()) is N or t < 0.1:
-            log.debug('waiting for video to start')
-            sleep(0.1)
-
-        workIndex = 0
-        while (ptr := _.playTimeRem()) is N or ptr > 0.1 or not _.eofReached():
-            workIndex = (workIndex + 1) % 60
-            if workIndex % 10 == 0:
-                _.verifyMpvRunning()  # | overkill but doesnt hurt `useSocketCM` will throw if dead
-            if ptr is N:
-                log.info('waiting for video to load', '')
-            yield from _.popEvents()
-            yield N  # | consumer can sleep
-        yield from _.popEvents()
-        log.debug('video ended')
-
-    def startVideo(_, source: str) -> Generator[MpvEvent | N, N, N]:
-        playListId = _.loadSource(source)
-        workIndex = 0
-        fileLoaded = F
-        while pc := _.sendCmd('get_property', 'playlist-count').data:
-            assert pc == 1
-
-            workIndex = (workIndex + 1) % 60
-            if workIndex % 10 == 0:
-                _.verifyMpvRunning()  # | overkill but doesnt hurt `useSocketCM` will throw if dead
-
-            for event in _.popEvents():
-                if fileLoaded:
-                    if event.event == 'end-file':
-                        # TODO not working
-                        _.sendCmd('stop')
-                    yield event
-                elif event.event == 'file-loaded':
-                    fileLoaded = T
-
-            if fileLoaded:
-                yield N  # | consumer can sleep
-            else:
-                sleep(0.1)
-
-        yield from _.popEvents()
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ logs / events
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-
-    def popEvents(_) -> Generator[dict, N, N]:
-        _._addLinesToCache()
-        while _._events:
-            yield _._events.pop(0)
-
-    def getLogs(_) -> Generator[str, N, N]:
-        with _.logPath.open('r') as fp:
-            while l := fp.readline():
-                yield l.strip()
-
-    _cacheLock: defl.ThreadLock = field(default_factory=defl.ThreadLock)
-
-    def _addLinesToCache(_) -> Self:
-        with _._cacheLock:
-            # print('_addLinesToCache')
-            # print('_addLinesToCache', 'lock')
-            recv = bytearray()
-
-            with _.useSocketCM():
-                while r := _._socket.recv(1024):  # | can cause process to receive 'Broken pipe' signal
-                    recv += r
-            recv = recv.split(b'\n')
-            for line in recv:
-                if not line:
-                    continue
-                line = json.loads(line)
-                match line:
-                    case {'event': __}:
-                        _._events.append(MpvEvent(**line))
-                    case {'request_id': __}:
-                        rid = line.pop('request_id')
-                        _._request[rid] = MpvRequest(**line)
-                    case __:
-                        raise NotImplementedError('')
-
-        # print('_addLinesToCache', 'unlock')
-        return _
-
-    def analyseFailLogs(_) -> MpvFailReason:
-        for line in _.logLines():
-            match line:
-                case str():
-                    ...
-                case dict():
-                    if line['module'] == '[ytdl_hook]' and 'Sign in to confirm your age.' in line['log']:
-                        return MpvFailReason.AgeRestricted
-                    if line['module'] == '[ffmpeg]' and 'https: HTTP error 403 Forbidden' in line['log']:
-                        return MpvFailReason.Forbidden403
-                case __:
-                    raise NotImplementedError(f'no match for {line}')
-
-    def logLines(_) -> Generator[dict, N, N]:
-        lineReg = re.compile(r'^(?P<time>\[[^\[]+\])(?P<level>\[[^\[]+\])(?P<module>\[[^\[]+\]) (?P<log>.*)')
-        for line in _.getLogs():
-            dic = lineReg.search(line)
-            if dic:
-                dic = dic.groupdict()
-                yield dic
-            else:
-                yield line
-
-    def eventIter(_) -> Generator[MpvEvent, N, N]:
-        # | avoids consuming on read
-        i = 0
-        lastEvent = N
-        while T:
-            if i < len(_._events):
-                if lastEvent:
-                    if _._events[i - 1] is not lastEvent:
-                        raise MpvEventsChangedOnIter('Changed Size')
-                lastEvent = _._events[i]
-                yield _._events[i]
-            else:
-                _._addLinesToCache()
-                yield N
-            i += 1
-
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # ◼◼ mpv commands
-    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼
-    # mpv --list-properties
-    # man mpv # "List of Input Commands"
-    # man mpv # "   Property list"
-
-    def loadSource(_, source: str) -> int:
-        _.logPath.writeText('')
-        _.sendCmd('stop')
-        _.sendCmd('playlist-clear')
-        return _.sendCmd(['loadfile', source]).data['playlist_entry_id']
-
-    def getProperty(_, prop: str) -> Any | N:
-        r = _.sendCmd(['get_property', prop])
-        match r:
-            case MpvRequest(error='success'):
-                return r.data
-            case MpvRequest(error='property unavailable'):
-                return N
-            case __:
-                raise NotImplementedError(f'no match for {r}')
-
-    def playTimeRem(_) -> float | N:
-        return _.getProperty('playtime-remaining')
-
-    def duration(_) -> float | N:
-        return _.getProperty('duration')
-
-    def fileName(_) -> str | N:
-        return _.getProperty('filename')
-
-    def curTime(_) -> str | N:
-        return _.getProperty('time-pos/full')
-
-    def eofReached(_) -> str | N:
-        return _.getProperty('eof-reached')
-
-    def quitMpv(_) -> float | N:
-        return _.sendCmd(['quit'])
-
-    def idleActive(_) -> float | N:
-        return _.getProperty('idle-active')
+#!/usr/bin/env python #!depricate
+#!depricate
+# TODO subtitiles #!depricate
+"""#!depricate
+# https://github.com/jaseg/python-mpv/blob/main/mpv.py #!depricate
+"""  #!depricate
+
+#!depricate
+from dataclasses import dataclass, field  #!depricate
+import re, threading  #!depricate
+import os  #!depricate
+import enum  #!depricate
+import json  #!depricate
+import atexit  #!depricate
+import socket  #!depricate
+from time import sleep  #!depricate
+from defl import (  #!depricate
+    cl,  #!depricate
+    log,  #!depricate
+    Dath,  #!depricate
+    Run,  #!depricate
+)  #!depricate
+from defl._typing_ import *  #!depricate
+from contextlib import contextmanager  #!depricate
+from defl._typing_ import T, F, N, U  #!depricate
+from defl._rich_ import *  #!depricate
+from defl.mpv2_ import *  #!depricate
+import defl  #!depricate
+
+
+#!depricate
+#!depricate
+# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+# ◼◼ Mpv Log Classes #!depricate
+# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+#!depricate
+#!depricate
+@dataclass(slots=T, kw_only=T, frozen=F)  #!depricate
+class MpvEvent:  #!depricate
+    event: str  #!depricate
+    reason: str | UT = U  #!depricate
+    file_error: str | UT = U  #!depricate
+    playlist_entry_id: int | UT = U  #!depricate
+
+
+#!depricate
+#!depricate
+@dataclass(slots=T, kw_only=T, frozen=F)  #!depricate
+class MpvRequest:  #!depricate
+    data: Any | UT = U  #!depricate
+    error: str  #!depricate
+
+    #!depricate
+    def success(_) -> bool:  #!depricate
+        return _.error == 'success'  #!depricate
+
+    #!depricate
+    def assSuc(_):  #!depricate
+        assert _.success(), _  #!depricate
+
+
+#!depricate
+#!depricate
+# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+# ◼◼ exceptions #!depricate
+# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+#!depricate
+#!depricate
+class MpvError(Exception):  #!depricate
+    __slot__ = ()  #!depricate
+
+
+#!depricate
+#!depricate
+class MpvSocketExistsError(MpvError):  #!depricate
+    __slot__ = ()  #!depricate
+
+
+#!depricate
+#!depricate
+class MpvRunningError(MpvError):  #!depricate
+    __slot__ = ()  #!depricate
+
+
+#!depricate
+#!depricate
+class MpvNoSocketFileError(MpvError):  #!depricate
+    __slot__ = ()  #!depricate
+
+
+#!depricate
+#!depricate
+class MpvNotRunningError(MpvError):  #!depricate
+    __slot__ = ()  #!depricate
+
+
+#!depricate
+#!depricate
+class MpvFailedToStartVideo(MpvError):  #!depricate
+    __slot__ = ()  #!depricate
+
+
+#!depricate
+#!depricate
+class MpvEventsChangedOnIter(MpvError, IndexError):  #!depricate
+    __slot__ = ()  #!depricate
+
+
+#!depricate
+#!depricate
+# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+# ◼◼ Enum #!depricate
+# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+#!depricate
+#!depricate
+class MpvFailReason(defl.Enumer):  #!depricate
+    AgeRestricted = enum.auto()  #!depricate
+    Forbidden403 = enum.auto()  #!depricate
+
+
+#!depricate
+#!depricate
+# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+# ◼◼ MPV #!depricate
+# ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+#!depricate
+#!depricate
+@dataclass(slots=T, kw_only=T, frozen=F)  #!depricate
+class Mpv:  #!depricate
+    _tmpPath: Dath = N  #!depricate
+    _run: Run | UT = U  #!depricate
+    _socket: socket.socket | UT = U  #!depricate
+    _events: list[MpvEvent] = field(default_factory=list, kw_only=T, repr=F)  #!depricate
+    _request: dict[int, MpvRequest] = field(default_factory=dict, kw_only=T, repr=F)  #!depricate
+    _running: bool = F  #!depricate
+
+    #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # ◼◼ printing #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    #!depricate
+    def richAutoReprSuper(_):  #!depricate
+        yield 'running', _._running  #!depricate
+
+    #!depricate
+    __rich_repr__ = defl.Obj.richAutoRepr  #!depricate
+    __str__ = defl.Obj.toRichRepr  #!depricate
+    __repr__ = defl.Obj.toRichRepr  #!depricate
+
+    #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # ◼◼ properies #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    #!depricate
+    @property  #!depricate
+    def running(_) -> bool:  #!depricate
+        return _._running  #!depricate
+
+    #!depricate
+    @property  #!depricate
+    def sockPath(_) -> Dath:  #!depricate
+        return _._tmpPath.reExt('sock')  #!depricate
+
+    #!depricate
+    @property  #!depricate
+    def logPath(_) -> Dath:  #!depricate
+        return _._tmpPath.reExt('log')  #!depricate
+
+    #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # ◼◼ init #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    #!depricate
+    def __post_init__(_) -> N:  #!depricate
+        _._tmpPath = Dath.Temp().temp(create=F)  #!depricate
+        # _.logPath.rmOnExit() #!depricate
+
+    #!depricate
+    def run(_) -> Run:  #!depricate
+        if _.sockPath.exists():  #!depricate
+            raise MpvSocketExistsError()  #!depricate
+        if _._run is not U and _._run.rc is N:  #!depricate
+            raise MpvRunningError()  #!depricate
+        if _._running:  #!depricate
+            raise MpvRunningError()  #!depricate
+        _._running = T  #!depricate
+        _._run = Run(_.cmd).run(N, N)  #!depricate
+        _._socket = _.connectToSocket()  #!depricate
+        atexit.register(_.exit)  #!depricate
+        return _._run  #!depricate
+
+    #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # ◼◼ CLI #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    #!depricate
+    _ydlQuality: str = 'worst[height>=320]/worst/worstaudio+worstvideo'  #!depricate
+
+    #!depricate
+    def ydlQualityGS(_, val: str = U) -> str:  #!depricate
+        if val is not U:  #!depricate
+            _._ydlQuality = val  #!depricate
+        return _._ydlQuality  #!depricate
+
+    #!depricate
+    _extraMpvOpt: list[str] = field(default_factory=list, kw_only=T, repr=T)  #!depricate
+
+    #!depricate
+    def extraMpvOptGS(_, *args: str, **kargs) -> list[str]:  #!depricate
+        _._extraMpvOpt.extend(args)  #!depricate
+        assert inst(_._extraMpvOpt, list)  #!depricate
+        return _._extraMpvOpt  #!depricate
+
+    #!depricate
+    @property  #!depricate
+    def cmd(_) -> list[str]:  #!depricate
+        empty = '/tmp/empty.mp4'  # | have to have a file to start #!depricate
+        s = 'anullsrc=r=44100:cl=mono'  #!depricate
+        cmd = ['ffmpeg', '-y', '-t', 0.1, '-s']  #!depricate
+        cmd += ['640x480', '-f', 'rawvideo', '-pix_fmt', 'rgb24', '-r', '25', '-i', '/dev/zero', empty]  #!depricate
+        # cmd = ['ffmpeg', '-y', '-f', 'lavfi', '-i', s, '-t', '0.1', '-q:a', '9', '-acodec', 'libmp3lame', empty] #!depricate
+        Run(cmd).run(T, T).assSuc()  #!depricate
+        #!depricate
+        home = os.environ['HOME']  #!depricate
+        ytOpt = [  #!depricate
+            f'--script-opts=ytdl_hook-ytdl_path={home}/.local/bin/yt-dlp',  #!depricate
+            f'--ytdl-format={_.ydlQualityGS()}',  #!depricate
+            '--ytdl-raw-options=no-playlist=',  #!depricate
+        ]  #!depricate
+        mpvOpt = [  #!depricate
+            # '--track-auto-selection=no', #!depricate
+            '--fullscreen=yes',  #!depricate
+            f'--input-ipc-server={_.sockPath}',  #!depricate
+            '--keep-open=always',  #!depricate
+            '--msg-level=all=error',  #!depricate
+            f'--log-file={_.logPath}',  #!depricate
+            '--idle=yes',  #!depricate
+        ]  #!depricate
+        return ['mpv', *mpvOpt, *ytOpt, *_.extraMpvOptGS(), '--', empty]  #!depricate
+
+    #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # ◼◼ socket communication #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    #!depricate
+    def connectToSocket(_) -> socket.socket:  #!depricate
+        i = 0  #!depricate
+        while not _.sockPath.exists():  #!depricate
+            i += 1  #!depricate
+            sleep(0.2)  #!depricate
+            log.info(f'wait for socket ({i})', _.sockPath, end=cl.startOfLine)  #!depricate
+            _.verifyMpvRunning()  #!depricate
+        #!depricate
+        retry = T  #!depricate
+        while retry:  #!depricate
+            with defl.IgnoreExceptionCM(ConnectionError):  #!depricate
+                sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)  #!depricate
+                sock.connect(_.sockPath.s)  #!depricate
+                sock.settimeout(0.2)  #!depricate
+                retry = F  #!depricate
+        #!depricate
+        return sock  #!depricate
+
+    #!depricate
+    _sendCmdId: int = 0  #!depricate
+
+    #!depricate
+    def sendCmd(_, *cmd) -> MpvRequest:  #!depricate
+        if len(cmd) == 1 and inst(cmd[0], list):  #!depricate
+            cmd = cmd[0]  #!depricate
+        #!depricate
+        if not _.sockPath.exists():  #!depricate
+            raise MpvNoSocketFileError()  #!depricate
+        #!depricate
+        idd = _._sendCmdId  #!depricate
+        log.debug(f'send cmd {idd}', lambda x: x.cmd)  #!depricate
+        _._sendCmdId = (_._sendCmdId + 1) % 99999  #!depricate
+        data = {'command': cmd, 'request_id': idd}  #!depricate
+        cmd = json.dumps(data).encode('utf8') + b'\n'  #!depricate
+        with _.useSocketCM():  #!depricate
+            _._socket.send(cmd)  #!depricate
+        #!depricate
+        while idd not in _._request:  #!depricate
+            # TODO optimize #!depricate
+            _._addLinesToCache()  #!depricate
+            sleep(0.05)  #!depricate
+        res = _._request.pop(idd)  #!depricate
+        log.debug(f'  -> cmd result {idd}', lambda x: x.res)  #!depricate
+        #!depricate
+        return res  #!depricate
+
+    #!depricate
+    @contextmanager  #!depricate
+    def useSocketCM(_):  #!depricate
+        try:  #!depricate
+            if _._socket is U:  #!depricate
+                _.verifyMpvRunning()  #!depricate
+            yield  #!depricate
+        except BrokenPipeError as e:  #!depricate
+            _.closeSocket()  #!depricate
+            _.exit()  #!depricate
+            _.verifyMpvRunning()  #!depricate
+            raise e  #!depricate
+        except TimeoutError:  #!depricate
+            ...  # | ignore #!depricate
+
+    #!depricate
+    def closeSocket(_) -> Self:  #!depricate
+        if _._socket is not U:  #!depricate
+            _._socket.close()  #!depricate
+        _._socket = U  #!depricate
+        return _  #!depricate
+
+    #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # ◼◼ controls #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    #!depricate
+    def verifyMpvRunning(_) -> Self:  #!depricate
+        if _._run.rc is not N:  #!depricate
+            raise MpvNotRunningError(f'{_._run.rc} {_.logPath}')  #!depricate
+        return _  #!depricate
+
+    #!depricate
+    def exit(_) -> Self:  #!depricate
+        if not _._running:  #!depricate
+            return _  #!depricate
+        atexit.unregister(_.exit)  #!depricate
+        log.info('quit mpv', '')  #!depricate
+        if _._socket is not U:  #!depricate
+            try:  #!depricate
+                _.quitMpv()  #!depricate
+            except MpvNotRunningError:  #!depricate
+                log.info('Already exited', '')  #!depricate
+        _.closeSocket()  #!depricate
+        _.sockPath.remove()  #!depricate
+        _._run.kill('int')  #!depricate
+        assert _._run.rc is not N  #!depricate
+        _._running = F  #!depricate
+        return _  #!depricate
+
+    #!depricate
+    def steamStartVideo(_, source: str) -> Generator[MpvEvent | N, N, N]:  #!depricate
+        oldDur = _.duration()  #!depricate
+        playListId = _.loadSource(source)  #!depricate
+        #!depricate
+        events = _.eventIter()  #!depricate
+        #!depricate
+        i = 0  #!depricate
+        while (duration := _.duration()) is N or duration == oldDur:  #!depricate
+            if i % 10 == 0:  #!depricate
+                _.verifyMpvRunning()  #!depricate
+                if _.idleActive():  #!depricate
+                    # TODO video display dissapears so next video fails. #!depricate
+                    raise MpvFailedToStartVideo(_.logPath)  #!depricate
+            i += 1  #!depricate
+            log.debug('waiting for video to load')  #!depricate
+            sleep(0.2)  #!depricate
+            while (event := next(events)) is not N:  #!depricate
+                log.info('event', lambda x: x.event)  #!depricate
+                if event.event == 'end-file':  #!depricate
+                    if event.playlist_entry_id == playListId:  #!depricate
+                        raise MpvFailedToStartVideo(event)  #!depricate
+        #!depricate
+        while (t := _.curTime()) is N or t < 0.1:  #!depricate
+            log.debug('waiting for video to start')  #!depricate
+            sleep(0.1)  #!depricate
+        #!depricate
+        workIndex = 0  #!depricate
+        while (ptr := _.playTimeRem()) is N or ptr > 0.1 or not _.eofReached():  #!depricate
+            workIndex = (workIndex + 1) % 60  #!depricate
+            if workIndex % 10 == 0:  #!depricate
+                _.verifyMpvRunning()  # | overkill but doesnt hurt `useSocketCM` will throw if dead #!depricate
+            if ptr is N:  #!depricate
+                log.info('waiting for video to load', '')  #!depricate
+            yield from _.popEvents()  #!depricate
+            yield N  # | consumer can sleep #!depricate
+        yield from _.popEvents()  #!depricate
+        log.debug('video ended')  #!depricate
+
+    #!depricate
+    def startVideo(_, source: str) -> Generator[MpvEvent | N, N, N]:  #!depricate
+        playListId = _.loadSource(source)  #!depricate
+        workIndex = 0  #!depricate
+        fileLoaded = F  #!depricate
+        while pc := _.sendCmd('get_property', 'playlist-count').data:  #!depricate
+            assert pc == 1  #!depricate
+            #!depricate
+            workIndex = (workIndex + 1) % 60  #!depricate
+            if workIndex % 10 == 0:  #!depricate
+                _.verifyMpvRunning()  # | overkill but doesnt hurt `useSocketCM` will throw if dead #!depricate
+            #!depricate
+            for event in _.popEvents():  #!depricate
+                if fileLoaded:  #!depricate
+                    if event.event == 'end-file':  #!depricate
+                        # TODO not working #!depricate
+                        _.sendCmd('stop')  #!depricate
+                    yield event  #!depricate
+                elif event.event == 'file-loaded':  #!depricate
+                    fileLoaded = T  #!depricate
+            #!depricate
+            if fileLoaded:  #!depricate
+                yield N  # | consumer can sleep #!depricate
+            else:  #!depricate
+                sleep(0.1)  #!depricate
+        #!depricate
+        yield from _.popEvents()  #!depricate
+
+    #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # ◼◼ logs / events #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    #!depricate
+    def popEvents(_) -> Generator[dict, N, N]:  #!depricate
+        _._addLinesToCache()  #!depricate
+        while _._events:  #!depricate
+            yield _._events.pop(0)  #!depricate
+
+    #!depricate
+    def getLogs(_) -> Generator[str, N, N]:  #!depricate
+        with _.logPath.open('r') as fp:  #!depricate
+            while l := fp.readline():  #!depricate
+                yield l.strip()  #!depricate
+
+    #!depricate
+    _cacheLock: defl.ThreadLock = field(default_factory=defl.ThreadLock)  #!depricate
+
+    #!depricate
+    def _addLinesToCache(_) -> Self:  #!depricate
+        with _._cacheLock:  #!depricate
+            # print('_addLinesToCache') #!depricate
+            # print('_addLinesToCache', 'lock') #!depricate
+            recv = bytearray()  #!depricate
+            #!depricate
+            with _.useSocketCM():  #!depricate
+                while r := _._socket.recv(1024):  # | can cause process to receive 'Broken pipe' signal #!depricate
+                    recv += r  #!depricate
+            recv = recv.split(b'\n')  #!depricate
+            for line in recv:  #!depricate
+                if not line:  #!depricate
+                    continue  #!depricate
+                line = json.loads(line)  #!depricate
+                match line:  #!depricate
+                    case {'event': __}:  #!depricate
+                        _._events.append(MpvEvent(**line))  #!depricate
+                    case {'request_id': __}:  #!depricate
+                        rid = line.pop('request_id')  #!depricate
+                        _._request[rid] = MpvRequest(**line)  #!depricate
+                    case __:  #!depricate
+                        raise NotImplementedError('')  #!depricate
+        #!depricate
+        # print('_addLinesToCache', 'unlock') #!depricate
+        return _  #!depricate
+
+    #!depricate
+    def analyseFailLogs(_) -> MpvFailReason:  #!depricate
+        for line in _.logLines():  #!depricate
+            match line:  #!depricate
+                case str():  #!depricate
+                    ...  #!depricate
+                case dict():  #!depricate
+                    if line['module'] == '[ytdl_hook]' and 'Sign in to confirm your age.' in line['log']:  #!depricate
+                        return MpvFailReason.AgeRestricted  #!depricate
+                    if line['module'] == '[ffmpeg]' and 'https: HTTP error 403 Forbidden' in line['log']:  #!depricate
+                        return MpvFailReason.Forbidden403  #!depricate
+                case __:  #!depricate
+                    raise NotImplementedError(f'no match for {line}')  #!depricate
+
+    #!depricate
+    def logLines(_) -> Generator[dict, N, N]:  #!depricate
+        lineReg = re.compile(
+            r'^(?P<time>\[[^\[]+\])(?P<level>\[[^\[]+\])(?P<module>\[[^\[]+\]) (?P<log>.*)'
+        )  #!depricate
+        for line in _.getLogs():  #!depricate
+            dic = lineReg.search(line)  #!depricate
+            if dic:  #!depricate
+                dic = dic.groupdict()  #!depricate
+                yield dic  #!depricate
+            else:  #!depricate
+                yield line  #!depricate
+
+    #!depricate
+    def eventIter(_) -> Generator[MpvEvent, N, N]:  #!depricate
+        # | avoids consuming on read #!depricate
+        i = 0  #!depricate
+        lastEvent = N  #!depricate
+        while T:  #!depricate
+            if i < len(_._events):  #!depricate
+                if lastEvent:  #!depricate
+                    if _._events[i - 1] is not lastEvent:  #!depricate
+                        raise MpvEventsChangedOnIter('Changed Size')  #!depricate
+                lastEvent = _._events[i]  #!depricate
+                yield _._events[i]  #!depricate
+            else:  #!depricate
+                _._addLinesToCache()  #!depricate
+                yield N  #!depricate
+            i += 1  #!depricate
+
+    #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # ◼◼ mpv commands #!depricate
+    # ◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼ #!depricate
+    # mpv --list-properties #!depricate
+    # man mpv # "List of Input Commands" #!depricate
+    # man mpv # "   Property list" #!depricate
+    #!depricate
+    def loadSource(_, source: str) -> int:  #!depricate
+        _.logPath.writeText('')  #!depricate
+        _.sendCmd('stop')  #!depricate
+        _.sendCmd('playlist-clear')  #!depricate
+        return _.sendCmd(['loadfile', source]).data['playlist_entry_id']  #!depricate
+
+    #!depricate
+    def getProperty(_, prop: str) -> Any | N:  #!depricate
+        r = _.sendCmd(['get_property', prop])  #!depricate
+        match r:  #!depricate
+            case MpvRequest(error='success'):  #!depricate
+                return r.data  #!depricate
+            case MpvRequest(error='property unavailable'):  #!depricate
+                return N  #!depricate
+            case __:  #!depricate
+                raise NotImplementedError(f'no match for {r}')  #!depricate
+
+    #!depricate
+    def playTimeRem(_) -> float | N:  #!depricate
+        return _.getProperty('playtime-remaining')  #!depricate
+
+    #!depricate
+    def duration(_) -> float | N:  #!depricate
+        return _.getProperty('duration')  #!depricate
+
+    #!depricate
+    def fileName(_) -> str | N:  #!depricate
+        return _.getProperty('filename')  #!depricate
+
+    #!depricate
+    def curTime(_) -> str | N:  #!depricate
+        return _.getProperty('time-pos/full')  #!depricate
+
+    #!depricate
+    def eofReached(_) -> str | N:  #!depricate
+        return _.getProperty('eof-reached')  #!depricate
+
+    #!depricate
+    def quitMpv(_) -> float | N:  #!depricate
+        return _.sendCmd(['quit'])  #!depricate
+
+    #!depricate
+    def idleActive(_) -> float | N:  #!depricate
+        return _.getProperty('idle-active')  #!depricate
+
+
+#!depricate
diff --git a/defl/pass_.py b/defl/pass_.py
index 0701a56..5707aa5 100644
--- a/defl/pass_.py
+++ b/defl/pass_.py
@@ -64,7 +64,7 @@ class PassDBKey:
             _.relative = _.relative.relativeTo(_.root)
         assert not _.relative.isAbsolute()
 
-    _absolute: Dath | N = N
+    _absolute: Dath | N = field(default=N, kw_only=T, repr=F)
 
     @property
     def absolute(_) -> Dath:
@@ -76,15 +76,18 @@ class PassDBKey:
         return _.root / _.relative
 
     def assertExists(_) -> Self:
-        if not _.absolute.exists():
+        if not _.exists():
             raise PassKeyNotFoundError(_.relative)
         return _
 
     def assertNotExists(_) -> Self:
-        if _.absolute.exists():
+        if _.exists():
             raise PassKeyAlreadyExistsError(_.relative)
         return _
 
+    def exists(_):
+        return _.absolute.exists()
+
 
 @dataclass(slots=T, kw_only=T, frozen=F)
 class PassDB:
@@ -161,9 +164,18 @@ class PassDB:
         if editor is N:
             user = os.environ['USER']
             editor = [
-                'vim',
-                '-c',
-                f'set nobackup | set nonumber | set noswapfile | set undodir=/dev/shm/{user} | startinsert',
+                *['vim', '-c'],
+                ' | '.join(
+                    [
+                        f'set nobackup',
+                        'set directory=/dev/shm/{user}',
+                        'set nowritebackup',
+                        'set nonumber',
+                        'set noswapfile',
+                        'set undodir=/dev/shm/{user}',
+                        'startinsert',
+                    ]
+                ),
             ]
 
         if isinstance(editor, str):
@@ -191,7 +203,7 @@ class PassDB:
             data = sys.stdin.read()
         _.mount()  # | timeout could unmount
         key.absolute.parent.mkdirForce()
-        key.absolute.writeText(data)
+        key.absolute.write(data)
         return _
 
     @contextmanager
@@ -234,10 +246,10 @@ class PassDB:
         return res
 
     def exists(_, key: str) -> bool:
-        key = _.getPassKey(key, assertNotExist=F)
+        key = _.getPassKey(key)
         if amCliEntryPoint():
-            sys.exit(0 if key.exists() else 1)
-        return key.parent.exists()
+            sys.exit(0 if key.absolute.exists() else 1)
+        return key.absolute.exists()
 
     def readLines(_, key: str, strip: bool = T) -> Generator[bytes, N, N]:
         key = _.getPassKey(key)
@@ -249,6 +261,8 @@ class PassDB:
     def cat(_, key: str) -> list[str] | N:
         res = [x.decode() for x in _.readLines(key)]
         if amCliEntryPoint():
+            if not res:
+                return res
             log.info(f'{cl.yel}{res[0]}{cl.r}')
             res = res[1:]
             while res and res[-1] == '':
@@ -288,14 +302,17 @@ class PassDB:
 
         with _.tempEdit(key=key) as tmpPath:
             text = _.cat(key)
-            oldPwd = text[0]
-            text[0] = newPasswd
-            text = list(itertools.dropwhile(lambda x: not x.strip(), text[::-1]))
-            text = text[::-1]  # | remove empty end lines
-            if not text[-1].startswith('oldPass | '):
-                text.append('')
-            text.append(f'oldPass | {Time()} | {oldPwd}')
-            tmpPath.writeText('\n'.join(text))
+            if text:
+                oldPwd = text[0]
+                text[0] = newPasswd
+                text = list(itertools.dropwhile(lambda x: not x.strip(), text[::-1]))
+                text = text[::-1]  # | remove empty end lines
+                if not text[-1].startswith('oldPass | '):
+                    text.append('')
+                text.append(f'oldPass | {Time()} | {oldPwd}')
+                tmpPath.writeText('\n'.join(text))
+            else:
+                tmpPath.writeText(newPasswd)
             if amCliEntryPoint():
                 _._openEditor(tmpPath)
                 if confirmContinue():
diff --git a/defl/proc_.py b/defl/proc_.py
index 0204229..9871650 100644
--- a/defl/proc_.py
+++ b/defl/proc_.py
@@ -110,10 +110,11 @@ class Kill:
         if isinstance(_.signal, int | str):
             _.signal = KillSig.KillMap[_.signal]
 
-    def kill(_, pid: int) -> int:
+    def kill(_, pid: int, wait: bool = T) -> int:
         sudo = ['sudo'] if _.sudo else []
         sp = subprocess.Popen(sudo + ['kill', '-s', _.signal.name, str(pid)])
-        sp.wait()
+        if wait:
+            sp.wait()
         return sp.returncode
 
 
diff --git a/defl/ssh_.py b/defl/ssh_.py
index 2aa065f..eab1eef 100644
--- a/defl/ssh_.py
+++ b/defl/ssh_.py
@@ -195,6 +195,8 @@ class SSH:
         Run(cmd).run(F, T).wait().assSuc()
 
     def ssh(_, *cmd, opt: SSHOptions = N) -> Run:
+        if len(cmd) == 1 and inst(cmd[0], list | tuple):
+            cmd = cmd[0]
         # TODO create a socket so doesnt restart every time
         return Run(_.sshCom(*cmd, opt=opt))
 
diff --git a/defl/testing_.py b/defl/testing_.py
deleted file mode 100644
index 7cc1b4e..0000000
--- a/defl/testing_.py
+++ /dev/null
@@ -1,247 +0,0 @@
-#!/usr/bin/env python
-
-# TODO use unit test libarary
-# TODO assertRaises
-# TODO show function src
-# TODO do something with description
-# TODO timeout
-# todo retry amount
-
-import collections
-import inspect, contextlib
-from dataclasses import dataclass, field, KW_ONLY
-from typing import Any, Callable
-import multiprocessing as mp
-
-from pandas import Timedelta
-import defl
-import sys, atexit
-from datetime import datetime
-import enum
-from defl import log, cl
-from defl.sheet_ import Sheet
-from defl._typing_ import *
-
-
-class TestError(Exception):
-    __slot__ = ()
-
-
-@contextlib.contextmanager
-def testFail(expt):
-    try:
-        yield
-        raise TestError("shouldn't reach here")
-    except expt:
-        ...
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class _TestNotRunSentinal:
-    pass
-
-
-class TestState(defl.Enumer):
-    Pending = enum.auto()
-    FailedWithException = enum.auto()
-    FailedAssert = enum.auto()
-    Success = enum.auto()
-
-
-def colorState(state):
-    stateString = str(state).strip('.')
-    if state is TestState.Pending:
-        col = cl.blu
-    elif state is TestState.Success:
-        col = cl.grn
-    elif state is TestState.FailedWithException:
-        col = cl.red
-    elif state is TestState.FailedAssert:
-        col = cl.yel
-    return f'{col}{stateString}{cl.r}'
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class _ExceptionWrap:
-    exc: str
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class ReturnMsg:
-    result: Any
-    stdText: Any
-    timeTaken: Any
-    exceptInfo: Any
-
-
-@dataclass(slots=T, kw_only=F, frozen=F)
-class Test:
-    func: Callable
-    __: KW_ONLY = KW_ONLY
-    assertResult: Any = N
-    assertExcept: Exception | N = N
-    state: TestState = TestState.Pending
-    result: Any = _TestNotRunSentinal
-    timeTaken: Timedelta | N = N
-    stdText: str | N = N
-
-    def _funcWrap(_, que) -> N:
-        defl.console = defl.Console()
-        # .clear_live()
-        with defl.OverrideWriterCM([sys.stdout, sys.stderr]) as std:
-            start = datetime.now()
-            try:
-                res = _.func()
-                exceptInfo = N
-            except Exception as e:
-                res = _ExceptionWrap(exc=type(e).__name__)
-                exceptInfo = defl.excInfoToString(*sys.exc_info())
-            que.put(
-                ReturnMsg(
-                    result=res,
-                    stdText=std.text(),
-                    timeTaken=datetime.now() - start,
-                    exceptInfo=exceptInfo,
-                )
-            )
-            que.close()
-
-    def fork(_) -> ReturnMsg:
-        "fork and get result"
-        # mp.set_start_method('spawn')
-        que = mp.Queue()
-        proc = mp.Process(target=_._funcWrap, args=(que,))
-        reg = atexit.register(proc.kill)
-        proc.start()
-        atexit.unregister(reg)
-        res = que.get()
-        proc.join()
-        return res
-
-    def run(_):
-        try:
-            res = _.fork()
-            _.stdText = res.stdText
-            _.timeTaken = res.timeTaken
-            if inst(res.result, _ExceptionWrap):
-                newExept = type(res.result.exc, (Exception,), {})
-                raise newExept
-            _.result = res.result
-            if _.assertResult is N:
-                _.state = TestState.Success
-            elif _.assertResult == _.result:
-                _.state = TestState.Success
-            else:
-                _.state = TestState.FailedAssert
-        except Exception as e:
-            _.result = defl.exceptName(e)  # + (f' : {str(e)}' if str(e) else '')
-            _.state = TestState.FailedWithException
-            # if isinstance(e, NotImplementedError):
-            #     return f'{cl.red}{defl.exceptName(e)}{cl.r}\n'
-            return res.exceptInfo
-
-    def toDict(_):
-        return {
-            'Line#': inspect.getsourcelines(_.func)[-1],
-            'Test': _.func.__name__,
-            'State': _.state,
-            'Result': _.result,
-            'AssertResult': _.assertResult if _.assertResult is not N else '',
-            'secs': _.timeTaken.total_seconds(),
-        }
-
-
-@dataclass(slots=T, kw_only=T, frozen=F)
-class Tester:
-    name: str
-    _tests: list[Test] = field(default_factory=list)
-
-    def add(_, *args, assertResult=N, description='', **kargs):
-        if args or kargs:
-            log.error(
-                'You did not initialize the outter test function like',
-                f'\n@tester.add{cl.red}(){cl.r}\ndef myFunction():\n\tpass',
-            )
-            log.error('You probably did', '\n@tester.add\ndef myFunction():\n\tpass')
-            raise ValueError()
-
-        def wrapOutter(func):
-            _._tests.append(Test(func, assertResult=assertResult))
-            return func
-
-        return wrapOutter
-
-    @dataclass(slots=T, kw_only=T, frozen=F)
-    class ResultsString:
-        header: list[str] = field(default_factory=list, repr=T)
-        body: list[str] = field(default_factory=list, repr=T)
-        results: list[str] = field(default_factory=list, repr=T)
-        footer: list[str] = field(default_factory=list, repr=T)
-
-        # TODO add helper functions for string format
-        def string(_):
-            if _.body:
-                res = defl.utf8box('\n'.join(_.results), cl.red)
-            else:
-                res = defl.utf8box('\n'.join(_.results), cl.green)
-            res = ['\n'.join(_.header), res, '\n'.join([x.strip() for x in _.body]), '\n'.join(_.footer)]
-            res = [x for x in res if x]
-            return '\n'.join(res)
-
-    def run(_):
-        # TODO sys.argv filter
-        resStr = Tester.ResultsString()
-        resStr.header.append(f'{cl.wht}◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼{cl.r}')
-        resStr.header.append(f'{cl.wht}◼◼ {_.name}{cl.r}')
-        resStr.header.append(f'{cl.wht}◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼◼{cl.r}')
-
-        def _run(t: Test):
-            excpt = t.run()
-            if excpt:
-                resStr.body.extend(
-                    [
-                        prog.inc(postmsg=t.func.__name__, premsg='◼◼', write=F) + cl.res,
-                        t.stdText,
-                        excpt,
-                    ]
-                )
-
-        prog = defl.ProgressPrint(len(_._tests))
-
-        def info(comPool: defl.ComPool):
-            r: list[defl.Fut] = [x for x in comPool._stillWaiting]
-            r: list[partial] = [x.func for x in r]
-            r: list[str] = [x.keywords['t'].func.__name__ for x in r]
-            return '\n'.join(r)
-
-        defl.ComPool([partial(_run, t=test) for test in _._tests], progressInfo=info).results()
-
-        resStr.results.append(f'{cl.wht}◼◼ Results : {_.name}{cl.r}')
-        if not _._tests:
-            raise ValueError(f'No tests to run {_.name}')
-        tab = Sheet([x.toDict() for x in _._tests])
-
-        tab['Test'] = [f'{cl.cyn}{x.Test}{cl.r}' for x in tab]
-        tab['State'] = [colorState(x.State) for x in tab]
-
-        failed = tab.clone()
-        failed = failed.filter(lambda x: 'Success' not in x['State'])
-
-        resStr.results.append(f'{tab}')
-
-        if resStr.body:
-            resStr.footer.append(f'{cl.wht}◼◼ failed : {_.name}{cl.r}')
-            resStr.footer.append(f'{failed}')
-
-        states = collections.Counter([x.state for x in _._tests])
-        resStr.results.append(f'{cl.wht}◼◼ Summary : {_.name}{cl.r}')
-        for k, v in states.items():
-            if v > 0:
-                resStr.results.append(f'{colorState(k): <25} {v}')
-        # res += f'    {cl.blu}{len(passed)} passed / {len(_._results)}{cl.r}'
-        return resStr.string()
-
-    def exitWithStatus(_):
-        if any(x.state is TestState.Pending for x in _._tests):
-            raise ValueError('Test was not run')
-        sys.exit(0 if all(x.state is TestState.Success for x in _._tests) else 1)
diff --git a/defl/thirdParty/get.sh b/defl/thirdParty/get.sh
index 180e069..9918a5f 100644
--- a/defl/thirdParty/get.sh
+++ b/defl/thirdParty/get.sh
@@ -1,3 +1,4 @@
 curl -s https://raw.githubusercontent.com/JulienPalard/Pipe/main/pipe.py > pipe.py
 curl -s https://raw.githubusercontent.com/naiquevin/pipdeptree/master/pipdeptree.py > pipdeptree.py
 curl -s https://raw.githubusercontent.com/martinblech/xmltodict/master/xmltodict.py > xmltodict.py
+curl -s https://raw.githubusercontent.com/jaseg/python-mpv/refs/heads/main/mpv.py > mpv.py
diff --git a/defl/thirdParty/mpv.py b/defl/thirdParty/mpv.py
new file mode 100644
index 0000000..b429f35
--- /dev/null
+++ b/defl/thirdParty/mpv.py
@@ -0,0 +1,2206 @@
+# -*- coding: utf-8 -*-
+# vim: ts=4 sw=4 et
+#
+# Python MPV library module
+# Copyright (C) 2017-2024 Sebastian Götte <code@jaseg.net>
+#
+# python-mpv inherits the underlying libmpv's license, which can be either GPLv2 or later (default) or LGPLv2.1 or
+# later. For details, see the mpv copyright page here: https://github.com/mpv-player/mpv/blob/master/Copyright
+#
+# You may copy, modify, and redistribute this file under the terms of the GNU General Public License version 2 (or, at
+# your option, any later version), or the GNU Lesser General Public License as published by the Free Software
+# Foundation; either version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License and the GNU
+# Lesser General Public License for more details.
+#
+# You can find copies of the GPLv2 and LGPLv2.1 licenses in the project repository's LICENSE.GPL and LICENSE.LGPL files.
+
+__version__ = '1.0.7'
+
+from ctypes import *
+import ctypes.util
+import threading
+import queue
+import os
+import os.path
+import sys
+from warnings import warn
+from functools import partial, wraps
+from contextlib import contextmanager
+from concurrent.futures import Future, InvalidStateError
+import collections
+import re
+import traceback
+
+if os.name == 'nt':
+    # Note: mpv-2.dll with API version 2 corresponds to mpv v0.35.0. Most things should work with the fallback, too.
+    names = ['mpv-2.dll', 'libmpv-2.dll', 'mpv-1.dll']
+    for name in names:
+        dll = ctypes.util.find_library(name)
+        if dll:
+            break
+    else:
+        for name in names:
+            dll = os.path.join(os.path.dirname(__file__), name)
+            if os.path.isfile(dll):
+                break
+        else:
+            raise OSError('Cannot find mpv-1.dll, mpv-2.dll or libmpv-2.dll in your system %PATH%. One way to deal with this is to ship the dll with your script and put the directory your script is in into %PATH% before "import mpv": os.environ["PATH"] = os.path.dirname(__file__) + os.pathsep + os.environ["PATH"] If mpv-1.dll is located elsewhere, you can add that path to os.environ["PATH"].')
+
+    try:
+        # flags argument: LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
+        # cf. https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibraryexa
+        backend = CDLL(dll, 0x00001000 | 0x00000100)
+    except Exception as e:
+        if not os.path.isabs(dll): # can only be find_library, not the "look next to mpv.py" thing
+            raise OSError(f'ctypes.find_library found mpv.dll at {dll}, but ctypes.CDLL could not load it. It looks like find_library found mpv.dll under a relative path entry in %PATH%. Please make sure all paths in %PATH% are absolute. Instead of trying to load mpv.dll from the current working directory, put it somewhere next to your script and add that path to %PATH% using os.environ["PATH"] = os.path.dirname(__file__) + os.pathsep + os.environ["PATH"]') from e
+        else:
+            raise OSError(f'ctypes.find_library found mpv.dll at {dll}, but ctypes.CDLL could not load it.') from e
+    fs_enc = 'utf-8'
+
+else:
+    import locale
+    lc, enc = locale.getlocale(locale.LC_NUMERIC)
+    # libmpv requires LC_NUMERIC to be set to "C". Since messing with global variables everyone else relies upon is
+    # still better than segfaulting, we are setting LC_NUMERIC to "C".
+    locale.setlocale(locale.LC_NUMERIC, 'C')
+
+    sofile = ctypes.util.find_library('mpv')
+    if sofile is None:
+        raise OSError("Cannot find libmpv in the usual places. Depending on your distro, you may try installing an mpv-devel or mpv-libs package. If you have libmpv around but this script can't find it, consult the documentation for ctypes.util.find_library which this script uses to look up the library filename.")
+    backend = CDLL(sofile)
+    fs_enc = sys.getfilesystemencoding()
+
+
+class ShutdownError(SystemError):
+    pass
+
+class EventOverflowError(SystemError):
+    pass
+
+class MpvHandle(c_void_p):
+    pass
+
+class MpvRenderCtxHandle(c_void_p):
+    pass
+
+class PropertyUnavailableError(AttributeError):
+    pass
+
+class ErrorCode(object):
+    """For documentation on these, see mpv's libmpv/client.h."""
+    SUCCESS                 = 0
+    EVENT_QUEUE_FULL        = -1
+    NOMEM                   = -2
+    UNINITIALIZED           = -3
+    INVALID_PARAMETER       = -4
+    OPTION_NOT_FOUND        = -5
+    OPTION_FORMAT           = -6
+    OPTION_ERROR            = -7
+    PROPERTY_NOT_FOUND      = -8
+    PROPERTY_FORMAT         = -9
+    PROPERTY_UNAVAILABLE    = -10
+    PROPERTY_ERROR          = -11
+    COMMAND                 = -12
+    LOADING_FAILED          = -13
+    AO_INIT_FAILED          = -14
+    VO_INIT_FAILED          = -15
+    NOTHING_TO_PLAY         = -16
+    UNKNOWN_FORMAT          = -17
+    UNSUPPORTED             = -18
+    NOT_IMPLEMENTED         = -19
+    GENERIC                 = -20
+
+    EXCEPTION_DICT = {
+             0:     None,
+            -1:     lambda *a: MemoryError('mpv event queue full', *a),
+            -2:     lambda *a: MemoryError('mpv cannot allocate memory', *a),
+            -3:     lambda *a: ValueError('Uninitialized mpv handle used', *a),
+            -4:     lambda *a: ValueError('Invalid value for mpv parameter', *a),
+            -5:     lambda *a: AttributeError('mpv option does not exist', *a),
+            -6:     lambda *a: TypeError('Tried to set mpv option using wrong format', *a),
+            -7:     lambda *a: ValueError('Invalid value for mpv option', *a),
+            -8:     lambda *a: AttributeError('mpv property does not exist', *a),
+            # Currently (mpv 0.18.1) there is a bug causing a PROPERTY_FORMAT error to be returned instead of
+            # INVALID_PARAMETER when setting a property-mapped option to an invalid value.
+            -9:     lambda *a: TypeError('Tried to get/set mpv property using wrong format, or passed invalid value', *a),
+            -10:    lambda *a: PropertyUnavailableError('mpv property is not available', *a),
+            -11:    lambda *a: RuntimeError('Generic error getting or setting mpv property', *a),
+            -12:    lambda *a: SystemError('Error running mpv command', *a),
+            -14:    lambda *a: RuntimeError('Initializing the audio output failed', *a),
+            -15:    lambda *a: RuntimeError('Initializing the video output failed'),
+            -16:    lambda *a: RuntimeError('There was no audio or video data to play. This also happens if the file '
+                                            'was recognized, but did not contain any audio or video streams, or no '
+                                            'streams were selected.'),
+            -17:    lambda *a: RuntimeError('When trying to load the file, the file format could not be determined, '
+                                            'or the file was too broken to open it'),
+            -18:    lambda *a: ValueError('Generic error for signaling that certain system requirements are not fulfilled'),
+            -19:    lambda *a: NotImplementedError('The API function which was called is a stub only'),
+            -20:    lambda *a: RuntimeError('Unspecified error') }
+
+    @staticmethod
+    def human_readable(ec):
+        return _mpv_error_string(ec).decode('utf-8')
+
+    @staticmethod
+    def default_error_handler(ec, *args):
+        return ValueError(ErrorCode.human_readable(ec), ec, *args)
+
+    @classmethod
+    def exception_for_ec(kls, ec, *args):
+        ec = 0 if ec > 0 else ec
+        ex = kls.EXCEPTION_DICT.get(ec, kls.default_error_handler)
+        if ex:
+            return ex(ec, *args)
+
+    @classmethod
+    def raise_for_ec(kls, ec, func, *args):
+        ex = kls.exception_for_ec(ec, *args)
+        if ex:
+            raise ex
+
+MpvGlGetProcAddressFn = CFUNCTYPE(c_void_p, c_void_p, c_char_p)
+class MpvOpenGLInitParams(Structure):
+    _fields_ = [('get_proc_address', MpvGlGetProcAddressFn),
+            ('get_proc_address_ctx', c_void_p),
+            ('extra_exts', c_void_p)]
+
+    def __init__(self, get_proc_address):
+        self.get_proc_address = get_proc_address
+        self.get_proc_address_ctx = None
+        self.extra_exts = None
+
+class MpvOpenGLFBO(Structure):
+    _fields_ = [('fbo', c_int),
+            ('w', c_int),
+            ('h', c_int),
+            ('internal_format', c_int)]
+
+    def __init__(self, w, h, fbo=0, internal_format=0):
+        self.w, self.h = w, h
+        self.fbo = fbo
+        self.internal_format = internal_format
+
+class MpvRenderFrameInfo(Structure):
+    _fields_ = [('flags', c_int64),
+            ('target_time', c_int64)]
+
+    def as_dict(self):
+        return {'flags': self.flags,
+                'target_time': self.target_time}
+
+class MpvOpenGLDRMParams(Structure):
+    _fields_ = [('fd', c_int),
+        ('crtc_id', c_int),
+        ('connector_id', c_int),
+        ('atomic_request_ptr', c_void_p),
+        ('render_fd', c_int)]
+
+class MpvOpenGLDRMDrawSurfaceSize(Structure):
+    _fields_ = [('width', c_int), ('height', c_int)]
+
+class MpvOpenGLDRMParamsV2(Structure):
+    _fields_ = [('fd', c_int),
+        ('crtc_id', c_int),
+        ('connector_id', c_int),
+        ('atomic_request_ptr', c_void_p),
+        ('render_fd', c_int)]
+
+    def __init__(self, crtc_id, connector_id, atomic_request_ptr, fd=-1, render_fd=-1):
+        self.crtc_id, self.connector_id = crtc_id, connector_id
+        self.atomic_request_ptr = atomic_request_ptr
+        self.fd, self.render_fd = fd, render_fd
+
+
+class MpvRenderParam(Structure):
+    _fields_ = [('type_id', c_int),
+                ('data', c_void_p)]
+
+    # maps human-readable type name to (type_id, argtype) tuple.
+    # The type IDs come from libmpv/render.h
+    TYPES = {"invalid"                 :(0, None),
+            "api_type"                 :(1, str),
+            "opengl_init_params"       :(2, MpvOpenGLInitParams),
+            "opengl_fbo"               :(3, MpvOpenGLFBO),
+            "flip_y"                   :(4, bool),
+            "depth"                    :(5, int),
+            "icc_profile"              :(6, bytes),
+            "ambient_light"            :(7, int),
+            "x11_display"              :(8, c_void_p),
+            "wl_display"               :(9, c_void_p),
+            "advanced_control"         :(10, bool),
+            "next_frame_info"          :(11, MpvRenderFrameInfo),
+            "block_for_target_time"    :(12, bool),
+            "skip_rendering"           :(13, bool),
+            "drm_display"              :(14, MpvOpenGLDRMParams),
+            "drm_draw_surface_size"    :(15, MpvOpenGLDRMDrawSurfaceSize),
+            "drm_display_v2"           :(16, MpvOpenGLDRMParamsV2)}
+
+    def __init__(self, name, value=None):
+        if name not in self.TYPES:
+            raise ValueError('unknown render param type "{}"'.format(name))
+        self.type_id, cons = self.TYPES[name]
+        if cons is None:
+            self.value = None
+            self.data = c_void_p()
+        elif cons is str:
+            self.value = value
+            self.data = cast(c_char_p(value.encode('utf-8')), c_void_p)
+        elif cons is bytes:
+            self.value = MpvByteArray(value)
+            self.data = cast(pointer(self.value), c_void_p)
+        elif cons is bool:
+            self.value = c_int(int(bool(value)))
+            self.data = cast(pointer(self.value), c_void_p)
+        elif cons is c_void_p:
+            self.value = value
+            self.data = cast(self.value, c_void_p)
+        else:
+            self.value = cons(**value)
+            self.data = cast(pointer(self.value), c_void_p)
+
+def kwargs_to_render_param_array(kwargs):
+    t = MpvRenderParam * (len(kwargs)+1)
+    return t(*kwargs.items(), ('invalid', None))
+
+class MpvFormat(c_int):
+    NONE        = 0
+    STRING      = 1
+    OSD_STRING  = 2
+    FLAG        = 3
+    INT64       = 4
+    DOUBLE      = 5
+    NODE        = 6
+    NODE_ARRAY  = 7
+    NODE_MAP    = 8
+    BYTE_ARRAY  = 9
+
+    def __eq__(self, other):
+        return self is other or self.value == other or self.value == int(other)
+
+    def __repr__(self):
+        return ['NONE', 'STRING', 'OSD_STRING', 'FLAG', 'INT64', 'DOUBLE', 'NODE', 'NODE_ARRAY', 'NODE_MAP',
+                'BYTE_ARRAY'][self.value]
+
+    def __hash__(self):
+        return self.value
+
+
+class MpvEventID(c_int):
+    NONE                    = 0
+    SHUTDOWN                = 1
+    LOG_MESSAGE             = 2
+    GET_PROPERTY_REPLY      = 3
+    SET_PROPERTY_REPLY      = 4
+    COMMAND_REPLY           = 5
+    START_FILE              = 6
+    END_FILE                = 7
+    FILE_LOADED             = 8
+    CLIENT_MESSAGE          = 16
+    VIDEO_RECONFIG          = 17
+    AUDIO_RECONFIG          = 18
+    SEEK                    = 20
+    PLAYBACK_RESTART        = 21
+    PROPERTY_CHANGE         = 22
+    QUEUE_OVERFLOW          = 24
+    HOOK                    = 25
+
+    ANY = ( SHUTDOWN, LOG_MESSAGE, GET_PROPERTY_REPLY, SET_PROPERTY_REPLY, COMMAND_REPLY, START_FILE, END_FILE,
+            FILE_LOADED, CLIENT_MESSAGE, VIDEO_RECONFIG, AUDIO_RECONFIG, SEEK, PLAYBACK_RESTART, PROPERTY_CHANGE)
+
+    def __repr__(self):
+        return f'<MpvEventID {self.value} {_mpv_event_name(self.value).decode("utf-8")}>'
+
+    @classmethod
+    def from_str(kls, s):
+        return getattr(kls, s.upper().replace('-', '_'))
+
+
+identity_decoder = lambda b: b
+strict_decoder = lambda b: b.decode('utf-8')
+def lazy_decoder(b):
+    try:
+        return b.decode('utf-8')
+    except UnicodeDecodeError:
+        return b
+
+class MpvNodeList(Structure):
+    def array_value(self, decoder=identity_decoder):
+        return [ self.values[i].node_value(decoder) for i in range(self.num) ]
+
+    def dict_value(self, decoder=identity_decoder):
+        return { self.keys[i].decode('utf-8'):
+                self.values[i].node_value(decoder) for i in range(self.num) }
+
+class MpvByteArray(Structure):
+    _fields_ = [('data', c_void_p),
+                ('size', c_size_t)]
+
+    def __init__(self, value):
+        self._value = value
+        self.data = cast(c_char_p(value), c_void_p)
+        self.size = len(value)
+
+    def bytes_value(self):
+        return cast(self.data, POINTER(c_char))[:self.size]
+
+class MpvNode(Structure):
+    def node_value(self, decoder=identity_decoder):
+        return MpvNode.node_cast_value(self.val, self.format.value, decoder)
+
+    @staticmethod
+    def node_cast_value(v, fmt=MpvFormat.NODE, decoder=identity_decoder):
+        if fmt == MpvFormat.NONE:
+            return None
+        elif fmt == MpvFormat.STRING:
+            return decoder(v.string)
+        elif fmt == MpvFormat.OSD_STRING:
+            return v.string.decode('utf-8')
+        elif fmt == MpvFormat.FLAG:
+            return bool(v.flag)
+        elif fmt == MpvFormat.INT64:
+            return v.int64
+        elif fmt == MpvFormat.DOUBLE:
+            return v.double
+        else:
+            if not v.node: # Check for null pointer
+                return None
+            if fmt == MpvFormat.NODE:
+                return v.node.contents.node_value(decoder)
+            elif fmt == MpvFormat.NODE_ARRAY:
+                return v.list.contents.array_value(decoder)
+            elif fmt == MpvFormat.NODE_MAP:
+                return v.map.contents.dict_value(decoder)
+            elif fmt == MpvFormat.BYTE_ARRAY:
+                return v.byte_array.contents.bytes_value()
+            else:
+                raise TypeError('Unknown MPV node format {}. Please submit a bug report.'.format(fmt))
+
+class MpvNodeUnion(Union):
+    _fields_ = [('string', c_char_p),
+                ('flag', c_int),
+                ('int64', c_int64),
+                ('double', c_double),
+                ('node', POINTER(MpvNode)),
+                ('list', POINTER(MpvNodeList)),
+                ('map', POINTER(MpvNodeList)),
+                ('byte_array', POINTER(MpvByteArray))]
+
+MpvNode._fields_ = [('val', MpvNodeUnion),
+                    ('format', MpvFormat)]
+
+MpvNodeList._fields_ = [('num', c_int),
+                        ('values', POINTER(MpvNode)),
+                        ('keys', POINTER(c_char_p))]
+
+class MpvEvent(Structure):
+    _fields_ = [('event_id', MpvEventID),
+                ('error', c_int),
+                ('reply_userdata', c_ulonglong),
+                ('_data', c_void_p)]
+
+    @property
+    def data(self):
+        dtype = {
+            MpvEventID.GET_PROPERTY_REPLY:     MpvEventProperty,
+            MpvEventID.PROPERTY_CHANGE:        MpvEventProperty,
+            MpvEventID.LOG_MESSAGE:            MpvEventLogMessage,
+            MpvEventID.CLIENT_MESSAGE:         MpvEventClientMessage,
+            MpvEventID.START_FILE:             MpvEventStartFile,
+            MpvEventID.END_FILE:               MpvEventEndFile,
+            MpvEventID.HOOK:                   MpvEventHook,
+            MpvEventID.COMMAND_REPLY:          MpvEventCommand,
+            }.get(self.event_id.value)
+        return cast(self._data, POINTER(dtype)).contents if dtype else None
+
+    def as_dict(self, decoder=identity_decoder):
+        out = cast(create_string_buffer(sizeof(MpvNode)), POINTER(MpvNode))
+        _mpv_event_to_node(out, pointer(self))
+        rv = out.contents.node_value(decoder=decoder)
+        _mpv_free_node_contents(out)
+        return rv
+
+    def __str__(self):
+        d = self.data
+        return f'<{type(d).__name__} ({self.event_id.value}) err={self.error} p={self.reply_userdata:016x} d={self.as_dict()}>'
+
+class MpvEventProperty(Structure):
+    _fields_ = [('_name', c_char_p),
+                ('format', MpvFormat),
+                ('data', MpvNodeUnion)]
+
+    @property
+    def name(self):
+        return self._name.decode("utf-8")
+
+    @property
+    def value(self):
+        return MpvNode.node_cast_value(self.data, self.format.value, decoder=lazy_decoder)
+
+class MpvEventLogMessage(Structure):
+    _fields_ = [('_prefix', c_char_p),
+                ('_level', c_char_p),
+                ('_text', c_char_p)]
+
+    @property
+    def prefix(self):
+        return self._prefix.decode("utf-8")
+
+    @property
+    def level(self):
+        return self._level.decode("utf-8")
+
+    @property
+    def text(self):
+        return lazy_decoder(self._text)
+
+class MpvEventEndFile(Structure):
+    _fields_ = [
+        ('reason', c_int),
+        ('error', c_int),
+        ('playlist_entry_id', c_ulonglong),
+        ('playlist_insert_id', c_ulonglong),
+        ('playlist_insert_num_entries', c_int),
+    ]
+
+    EOF                 = 0
+    RESTARTED           = 1
+    ABORTED             = 2
+    QUIT                = 3
+    ERROR               = 4
+    REDIRECT            = 5
+
+class MpvEventStartFile(Structure):
+    _fields_ = [('playlist_entry_id', c_ulonglong),]
+
+class MpvEventClientMessage(Structure):
+    _fields_ = [('_num_args', c_int),
+                ('_args', POINTER(c_char_p))]
+
+    @property
+    def args(self):
+        return [ self._args[i] for i in range(self._num_args) ]
+
+class MpvEventCommand(Structure):
+    _fields_ = [('_result', MpvNode)]
+
+    def unpack(self, decoder=identity_decoder):
+        return self._result.node_value(decoder=decoder)
+
+    @property
+    def result(self):
+        return self.unpack()
+
+class MpvEventHook(Structure):
+    _fields_ = [('_name', c_char_p),
+                ('id', c_ulonglong),]
+
+
+    @property
+    def name(self):
+        return self._name.decode("utf-8")
+
+StreamReadFn = CFUNCTYPE(c_int64, c_void_p, POINTER(c_char), c_uint64)
+StreamSeekFn = CFUNCTYPE(c_int64, c_void_p, c_int64)
+StreamSizeFn = CFUNCTYPE(c_int64, c_void_p)
+StreamCloseFn = CFUNCTYPE(None, c_void_p)
+StreamCancelFn = CFUNCTYPE(None, c_void_p)
+
+class StreamCallbackInfo(Structure):
+    _fields_ = [('cookie', c_void_p),
+                ('read', StreamReadFn),
+                ('seek', StreamSeekFn),
+                ('size', StreamSizeFn),
+                ('close', StreamCloseFn),
+                ('cancel', StreamCancelFn)]
+
+StreamOpenFn = CFUNCTYPE(c_int, c_void_p, c_char_p, POINTER(StreamCallbackInfo))
+
+WakeupCallback = CFUNCTYPE(None, c_void_p)
+
+RenderUpdateFn = CFUNCTYPE(None, c_void_p)
+
+def _handle_func(name, args, restype, errcheck, ctx=MpvHandle, deprecated=False):
+    func = getattr(backend, name)
+    func.argtypes = [ctx] + args if ctx else args
+    if restype is not None:
+        func.restype = restype
+    if errcheck is not None:
+        func.errcheck = errcheck
+    if deprecated:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if not wrapper.warned: # Only warn on first invocation to prevent spamming
+                warn("Backend C api has been deprecated: " + name, DeprecationWarning, stacklevel=2)
+                wrapper.warned = True
+            return func(*args, **kwargs)
+        wrapper.warned = False
+
+        globals()['_'+name] = wrapper
+    else:
+        globals()['_'+name] = func
+
+def bytes_free_errcheck(res, func, *args):
+    notnull_errcheck(res, func, *args)
+    rv = cast(res, c_void_p).value
+    _mpv_free(res)
+    return rv
+
+def notnull_errcheck(res, func, *args):
+    if res is None:
+        raise RuntimeError('Underspecified error in MPV when calling {} with args {!r}: NULL pointer returned.'\
+                'Please consult your local debugger.'.format(func.__name__, args))
+    return res
+
+ec_errcheck = ErrorCode.raise_for_ec
+
+backend.mpv_client_api_version.restype = c_ulong
+def _mpv_client_api_version():
+    ver = backend.mpv_client_api_version()
+    return ver>>16, ver&0xFFFF
+
+MPV_VERSION = _mpv_client_api_version()
+if MPV_VERSION < (1, 108):
+    ver = '.'.join(str(num) for num in MPV_VERSION)
+    raise RuntimeError(f"python-mpv requires libmpv with an API version of 1.108 or higher (libmpv >= 0.33), but you have an older version ({ver}).")
+
+backend.mpv_free.argtypes = [c_void_p]
+_mpv_free = backend.mpv_free
+
+backend.mpv_free_node_contents.argtypes = [c_void_p]
+_mpv_free_node_contents = backend.mpv_free_node_contents
+
+backend.mpv_create.restype = MpvHandle
+_mpv_create = backend.mpv_create
+
+_handle_func('mpv_create_client',           [c_char_p],                                 MpvHandle, notnull_errcheck)
+_handle_func('mpv_create_weak_client',      [c_char_p],                                 MpvHandle, notnull_errcheck)
+_handle_func('mpv_client_name',             [],                                         c_char_p, errcheck=None)
+_handle_func('mpv_initialize',              [],                                         c_int, ec_errcheck)
+_handle_func('mpv_destroy',                 [],                                         None, errcheck=None)
+_handle_func('mpv_terminate_destroy',       [],                                         None, errcheck=None)
+_handle_func('mpv_load_config_file',        [c_char_p],                                 c_int, ec_errcheck)
+_handle_func('mpv_get_time_us',             [],                                         c_ulonglong, errcheck=None)
+
+_handle_func('mpv_set_option',              [c_char_p, MpvFormat, c_void_p],            c_int, ec_errcheck)
+_handle_func('mpv_set_option_string',       [c_char_p, c_char_p],                       c_int, ec_errcheck)
+
+_handle_func('mpv_command',                 [POINTER(c_char_p)],                        c_int, ec_errcheck)
+_handle_func('mpv_command_string',          [c_char_p, c_char_p],                       c_int, ec_errcheck)
+_handle_func('mpv_command_async',           [c_ulonglong, POINTER(c_char_p)],           c_int, ec_errcheck)
+_handle_func('mpv_command_node',            [POINTER(MpvNode), POINTER(MpvNode)],       c_int, ec_errcheck)
+_handle_func('mpv_command_node_async',      [c_ulonglong, POINTER(MpvNode)],            c_int, ec_errcheck)
+_handle_func('mpv_abort_async_command',     [c_ulonglong],                              None, errcheck=None)
+
+_handle_func('mpv_set_property',            [c_char_p, MpvFormat, c_void_p],            c_int, ec_errcheck)
+_handle_func('mpv_set_property_string',     [c_char_p, c_char_p],                       c_int, ec_errcheck)
+_handle_func('mpv_set_property_async',      [c_ulonglong, c_char_p, MpvFormat,c_void_p],c_int, ec_errcheck)
+_handle_func('mpv_get_property',            [c_char_p, MpvFormat, c_void_p],            c_int, ec_errcheck)
+_handle_func('mpv_get_property_string',     [c_char_p],                                 c_void_p, bytes_free_errcheck)
+_handle_func('mpv_get_property_osd_string', [c_char_p],                                 c_void_p, bytes_free_errcheck)
+_handle_func('mpv_get_property_async',      [c_ulonglong, c_char_p, MpvFormat],         c_int, ec_errcheck)
+_handle_func('mpv_observe_property',        [c_ulonglong, c_char_p, MpvFormat],         c_int, ec_errcheck)
+_handle_func('mpv_unobserve_property',      [c_ulonglong],                              c_int, ec_errcheck)
+
+_handle_func('mpv_event_name',              [c_int],                                    c_char_p, errcheck=None, ctx=None)
+_handle_func('mpv_event_to_node',           [POINTER(MpvNode), POINTER(MpvEvent)],      c_int, ec_errcheck, ctx=None)
+_handle_func('mpv_error_string',            [c_int],                                    c_char_p, errcheck=None, ctx=None)
+
+_handle_func('mpv_request_event',           [MpvEventID, c_int],                        c_int, ec_errcheck)
+_handle_func('mpv_request_log_messages',    [c_char_p],                                 c_int, ec_errcheck)
+_handle_func('mpv_wait_event',              [c_double],                                 POINTER(MpvEvent), errcheck=None)
+_handle_func('mpv_wakeup',                  [],                                         None, errcheck=None)
+_handle_func('mpv_set_wakeup_callback',     [WakeupCallback, c_void_p],                 None, errcheck=None)
+
+_handle_func('mpv_stream_cb_add_ro',        [c_char_p, c_void_p, StreamOpenFn],         c_int, ec_errcheck)
+
+_handle_func('mpv_render_context_create',               [MpvRenderCtxHandle, MpvHandle, POINTER(MpvRenderParam)],   c_int, ec_errcheck,     ctx=None)
+_handle_func('mpv_render_context_set_parameter',        [MpvRenderParam],                                           c_int, ec_errcheck,     ctx=MpvRenderCtxHandle)
+_handle_func('mpv_render_context_get_info',             [MpvRenderParam],                                           c_int, ec_errcheck,     ctx=MpvRenderCtxHandle)
+_handle_func('mpv_render_context_set_update_callback',  [RenderUpdateFn, c_void_p],                                 None, errcheck=None,    ctx=MpvRenderCtxHandle)
+_handle_func('mpv_render_context_update',               [],                                                         c_int64, errcheck=None, ctx=MpvRenderCtxHandle)
+_handle_func('mpv_render_context_render',               [POINTER(MpvRenderParam)],                                  c_int, ec_errcheck,     ctx=MpvRenderCtxHandle)
+_handle_func('mpv_render_context_report_swap',          [],                                                         None, errcheck=None,    ctx=MpvRenderCtxHandle)
+_handle_func('mpv_render_context_free',                 [],                                                         None, errcheck=None,    ctx=MpvRenderCtxHandle)
+
+
+def _mpv_coax_proptype(value, proptype=str):
+    """Intelligently coax the given python value into something that can be understood as a proptype property."""
+    if type(value) is bytes:
+        return value;
+    elif type(value) is bool:
+        return b'yes' if value else b'no'
+    elif proptype in (str, int, float):
+        return str(proptype(value)).encode('utf-8')
+    else:
+        raise TypeError('Cannot coax value of type {} into property type {}'.format(type(value), proptype))
+
+def _make_node_str_list(l):
+    """Take a list of python objects and make a MPV string node array from it.
+
+    As an example, the python list ``l = [ "foo", 23, false ]`` will result in the following MPV node object::
+
+        struct mpv_node {
+            .format = MPV_NODE_ARRAY,
+            .u.list = *(struct mpv_node_array){
+                .num = len(l),
+                .keys = NULL,
+                .values = struct mpv_node[len(l)] {
+                    { .format = MPV_NODE_STRING, .u.string = l[0] },
+                    { .format = MPV_NODE_STRING, .u.string = l[1] },
+                    ...
+                }
+            }
+        }
+    """
+    char_ps = [ c_char_p(_mpv_coax_proptype(e, str)) for e in l ]
+    node_list = MpvNodeList(
+        num=len(l),
+        keys=None,
+        values=( MpvNode * len(l))( *[ MpvNode(
+                format=MpvFormat.STRING,
+                val=MpvNodeUnion(string=p))
+            for p in char_ps ]))
+    node = MpvNode(
+        format=MpvFormat.NODE_ARRAY,
+        val=MpvNodeUnion(list=pointer(node_list)))
+    return char_ps, node_list, node, cast(pointer(node), c_void_p)
+
+def _make_node_str_map(d):
+    """Take a dict of python objects and make a MPV string node map from it. """
+    char_ps = [ (c_char_p(k.encode('utf-8')), c_char_p(_mpv_coax_proptype(v, str))) for k, v in d.items() ]
+    node_list = MpvNodeList(
+        num=len(d),
+        keys=( c_char_p * len(d))( *[k for k, v in char_ps] ),
+        values=( MpvNode * len(d))( *[ MpvNode(
+                format=MpvFormat.STRING,
+                val=MpvNodeUnion(string=v))
+            for k, v in char_ps ]))
+    node = MpvNode(
+        format=MpvFormat.NODE_MAP,
+        val=MpvNodeUnion(map=pointer(node_list)))
+    return char_ps, node_list, node, cast(pointer(node), c_void_p)
+
+
+def _event_generator(handle):
+    while True:
+        event = _mpv_wait_event(handle, -1).contents
+        if event.event_id.value == MpvEventID.NONE:
+            raise StopIteration()
+        yield event
+
+
+def _create_null_term_cmd_arg_array(name, args):
+    args = [name.encode('utf-8')] + [(arg if type(arg) is bytes else str(arg).encode('utf-8'))
+                                     for arg in args if arg is not None] + [None]
+    return (c_char_p * len(args))(*args)
+
+
+_py_to_mpv = lambda name: name.replace('_', '-')
+_mpv_to_py = lambda name: name.replace('-', '_')
+
+_drop_nones = lambda *args: [ arg for arg in args if arg is not None ]
+
+class _Proxy:
+    def __init__(self, mpv):
+        super().__setattr__('mpv', mpv)
+
+class _PropertyProxy(_Proxy):
+    def __dir__(self):
+        return super().__dir__() + [ name.replace('-', '_') for name in self.mpv.property_list ]
+
+class _FileLocalProxy(_Proxy):
+    def __getitem__(self, name):
+        return self.mpv.__getitem__(name, file_local=True)
+
+    def __setitem__(self, name, value):
+        return self.mpv.__setitem__(name, value, file_local=True)
+
+    def __iter__(self):
+        return iter(self.mpv)
+
+class _OSDPropertyProxy(_PropertyProxy):
+    def __getattr__(self, name):
+        return self.mpv._get_property(_py_to_mpv(name), fmt=MpvFormat.OSD_STRING)
+
+    def __setattr__(self, _name, _value):
+        raise AttributeError('OSD properties are read-only. Please use the regular property API for writing.')
+
+class _DecoderPropertyProxy(_PropertyProxy):
+    def __init__(self, mpv, decoder):
+        super().__init__(mpv)
+        super().__setattr__('_decoder', decoder)
+
+    def __getattr__(self, name):
+        return self.mpv._get_property(_py_to_mpv(name), decoder=self._decoder)
+
+    def __setattr__(self, name, value):
+        setattr(self.mpv, _py_to_mpv(name), value)
+
+class GeneratorStream:
+    """Transform a python generator into an mpv-compatible stream object. The total size of the file can be indicated to
+    mpv using the size argument to __init__. Seeking is not supported.
+    """
+
+    def __init__(self, generator_fun, size=None):
+        self._generator_fun = generator_fun
+        self.size = size
+
+    def seek(self, offset):
+        self._read_iter = iter(self._generator_fun())
+        self._read_chunk = b''
+        return 0 # We only support seeking to the first byte atm
+        # implementation in case seeking to arbitrary offsets would be necessary
+        # while offset > 0:
+        #     offset -= len(self.read(offset))
+        # return offset
+
+    def read(self, size):
+        if not self._read_chunk:
+            try:
+                self._read_chunk += next(self._read_iter)
+            except StopIteration:
+                return b''
+        rv, self._read_chunk = self._read_chunk[:size], self._read_chunk[size:]
+        return rv
+
+    def close(self):
+        self._read_iter = iter([]) # make next read() call return EOF
+
+    def cancel(self):
+        self._read_iter = iter([]) # make next read() call return EOF
+
+
+class ImageOverlay:
+    def __init__(self, m, overlay_id, img=None, pos=(0, 0)):
+        self.m = m
+        self.overlay_id = overlay_id
+        self.pos = pos
+        self._size = None
+        if img is not None:
+            self.update(img)
+
+    def update(self, img=None, pos=None):
+        from PIL import Image
+        if img is not None:
+            self.img = img
+        img = self.img
+
+        w, h = img.size
+        stride = w*4
+
+        if pos is not None:
+            self.pos = pos
+        x, y = self.pos
+
+        # Pre-multiply alpha channel
+        bg = Image.new('RGBA', (w, h),  (0, 0, 0, 0))
+        out = Image.alpha_composite(bg, img)
+
+        # Copy image to ctypes buffer
+        if img.size != self._size:
+            self._buf = create_string_buffer(w*h*4)
+            self._size = img.size
+
+        ctypes.memmove(self._buf, out.tobytes('raw', 'BGRA'), w*h*4)
+        source = '&' + str(addressof(self._buf))
+
+        self.m.overlay_add(self.overlay_id, x, y, source, 0, 'bgra', w, h, stride)
+
+    def remove(self):
+        self.m.remove_overlay(self.overlay_id)
+
+
+class FileOverlay:
+    def __init__(self, m, overlay_id, filename=None, size=None, stride=None, pos=(0,0)):
+        self.m = m
+        self.overlay_id = overlay_id
+        self.pos = pos
+        self.size = size
+        self.stride = stride
+        if filename is not None:
+            self.update(filename)
+
+    def update(self, filename=None, size=None, stride=None, pos=None):
+        if filename is not None:
+            self.filename = filename
+
+        if pos is not None:
+            self.pos = pos
+
+        if size is not None:
+            self.size = size
+
+        if stride is not None:
+            self.stride = stride
+
+        x, y = self.pos
+        w, h = self.size
+        stride = self.stride or 4*w
+
+        self.m.overlay_add(self, self.overlay_id, x, y, self.filename, 0, 'bgra', w, h, stride)
+
+    def remove(self):
+        self.m.remove_overlay(self.overlay_id)
+
+
+class MPV(object):
+    """See man mpv(1) for the details of the implemented commands. All mpv properties can be accessed as
+    ``my_mpv.some_property`` and all mpv options can be accessed as ``my_mpv['some-option']``.
+
+    By default, properties are returned as decoded ``str`` and an error is thrown if the value does not contain valid
+    utf-8. To get a decoded ``str`` if possibly but ``bytes`` instead of an error if not, use
+    ``my_mpv.lazy.some_property``. To always get raw ``bytes``, use ``my_mpv.raw.some_property``.  To access a
+    property's decoded OSD value, use ``my_mpv.osd.some_property``.
+
+    To get API information on an option, use ``my_mpv.option_info('option-name')``. To get API information on a
+    property, use ``my_mpv.properties['property-name']``. Take care to use mpv's dashed-names instead of the
+    underscore_names exposed on the python object.
+
+    To make your program not barf hard the first time its used on a weird file system **always** access properties
+    containing file names or file tags through ``MPV.raw``.  """
+
+    def __init__(self, *extra_mpv_flags, log_handler=None, start_event_thread=True, loglevel=None, **extra_mpv_opts):
+        """Create an MPV instance.
+
+        Extra arguments and extra keyword arguments will be passed to mpv as options.
+        """
+
+        self.handle = _mpv_create()
+        self._event_thread = None
+        self._core_shutdown = False
+
+        _mpv_set_option_string(self.handle, b'audio-display', b'no')
+        istr = lambda o: ('yes' if o else 'no') if type(o) is bool else str(o)
+        try:
+            for flag in extra_mpv_flags:
+                _mpv_set_option_string(self.handle, flag.encode('utf-8'), b'')
+            for k,v in extra_mpv_opts.items():
+                _mpv_set_option_string(self.handle, k.replace('_', '-').encode('utf-8'), istr(v).encode('utf-8'))
+        finally:
+            _mpv_initialize(self.handle)
+
+        self.osd = _OSDPropertyProxy(self)
+        self.file_local = _FileLocalProxy(self)
+        self.raw    = _DecoderPropertyProxy(self, identity_decoder)
+        self.strict = _DecoderPropertyProxy(self, strict_decoder)
+        self.lazy   = _DecoderPropertyProxy(self, lazy_decoder)
+
+        self._event_callbacks = []
+        self._command_reply_callbacks = {}
+        self._event_handler_lock = threading.Lock()
+        self._property_handlers = collections.defaultdict(lambda: [])
+        self._quit_handlers = set()
+        self._message_handlers = {}
+        self._key_binding_handlers = {}
+        self._event_handle = _mpv_create_client(self.handle, b'py_event_handler')
+        self._log_handler = log_handler
+        self._stream_protocol_cbs = {}
+        self._stream_protocol_frontends = collections.defaultdict(lambda: {})
+        self.register_stream_protocol('python', self._python_stream_open)
+        self._python_streams = {}
+        self._python_stream_catchall = None
+        self._exception_futures = set()
+        self.overlay_ids = set()
+        self.overlays = {}
+        if loglevel is not None or log_handler is not None:
+            self.set_loglevel(loglevel or 'terminal-default')
+        if start_event_thread:
+            self._event_thread = threading.Thread(target=self._loop, name='MPVEventHandlerThread')
+            self._event_thread.daemon = True
+            self._event_thread.start()
+        else:
+            self._event_thread = None
+        if (m := re.search(r'(\d+)\.(\d+)\.(\d+)', self.mpv_version)):
+            self.mpv_version_tuple = tuple(map(int, m.groups()))
+
+    @contextmanager
+    def _enqueue_exceptions(self):
+        try:
+            yield
+        except Exception as e:
+            for fut in self._exception_futures:
+                try:
+                    fut.set_exception(e)
+                    break
+                except InvalidStateError:
+                    pass
+            else:
+                warn(f'Unhandled exception on python-mpv event loop: {e}\n{traceback.format_exc()}', RuntimeWarning)
+
+    def _loop(self):
+        for event in _event_generator(self._event_handle):
+            try:
+                eid = event.event_id.value
+
+                with self._event_handler_lock:
+                    if eid == MpvEventID.SHUTDOWN:
+                        self._core_shutdown = True
+
+                for callback in self._event_callbacks:
+                    with self._enqueue_exceptions():
+                        callback(event)
+
+                if eid == MpvEventID.PROPERTY_CHANGE:
+                    pc = event.data
+                    name, value, _fmt = pc.name, pc.value, pc.format
+                    for handler in self._property_handlers[name]:
+                        with self._enqueue_exceptions():
+                            handler(name, value)
+
+                if eid == MpvEventID.LOG_MESSAGE and self._log_handler is not None:
+                    ev = event.data
+                    with self._enqueue_exceptions():
+                        self._log_handler(ev.level, ev.prefix, ev.text)
+
+                if eid == MpvEventID.CLIENT_MESSAGE:
+                    # {'event': {'args': ['key-binding', 'foo', 'u-', 'g']}, 'reply_userdata': 0, 'error': 0, 'event_id': 16}
+                    target, *args = event.data.args
+                    target = target.decode("utf-8")
+                    if target in self._message_handlers:
+                        with self._enqueue_exceptions():
+                            self._message_handlers[target](*args)
+
+                if eid == MpvEventID.COMMAND_REPLY:
+                    key = event.reply_userdata
+                    callback = self._command_reply_callbacks.pop(key, None)
+                    if callback:
+                        with self._enqueue_exceptions():
+                            callback(ErrorCode.exception_for_ec(event.error), event.data)
+
+                if eid == MpvEventID.QUEUE_OVERFLOW:
+                    # cache list, since error handlers will unregister themselves
+                    for cb in list(self._command_reply_callbacks.values()):
+                        with self._enqueue_exceptions():
+                            cb(EventOverflowError('libmpv event queue has flown over because events have not been processed fast enough'), None)
+
+                if eid == MpvEventID.SHUTDOWN:
+                    _mpv_destroy(self._event_handle)
+                    for cb in list(self._command_reply_callbacks.values()):
+                        with self._enqueue_exceptions():
+                            cb(ShutdownError('libmpv core has been shutdown'), None)
+                    return
+
+            except Exception as e:
+                warn(f'Unhandled {e} inside python-mpv event loop!\n{traceback.format_exc()}', RuntimeWarning)
+
+    @property
+    def core_shutdown(self):
+        """Property indicating whether the core has been shut down. Possible causes for this are e.g. the `quit` command
+        or a user closing the mpv window."""
+        return self._core_shutdown
+
+    def check_core_alive(self):
+        """ This method can be used as a sanity check to tests whether the core is still alive at the time it is
+        called."""
+        if self._core_shutdown:
+            raise ShutdownError('libmpv core has been shutdown')
+
+    def wait_until_paused(self, timeout=None, catch_errors=True):
+        """Waits until playback of the current title is paused or done. Raises a ShutdownError if the core is shutdown while
+        waiting."""
+        self.wait_for_property('core-idle', timeout=timeout, catch_errors=catch_errors)
+
+    def wait_for_playback(self, timeout=None, catch_errors=True):
+        """Waits until playback of the current title is finished. Raises a ShutdownError if the core is shutdown while
+        waiting.
+        """
+        self.wait_for_event('end_file', timeout=timeout, catch_errors=catch_errors)
+
+    def wait_until_playing(self, timeout=None, catch_errors=True):
+        """Waits until playback of the current title has started. Raises a ShutdownError if the core is shutdown while
+        waiting."""
+        self.wait_for_property('core-idle', lambda idle: not idle, timeout=timeout, catch_errors=catch_errors)
+
+    def wait_for_property(self, name, cond=lambda val: val, level_sensitive=True, timeout=None, catch_errors=True):
+        """Waits until ``cond`` evaluates to a truthy value on the named property. This can be used to wait for
+        properties such as ``idle_active`` indicating the player is done with regular playback and just idling around.
+        Raises a ShutdownError when the core is shutdown while waiting.
+        """
+        with self.prepare_and_wait_for_property(name, cond, level_sensitive, timeout=timeout, catch_errors=catch_errors) as result:
+            pass
+        return result.result()
+
+    def wait_for_shutdown(self, timeout=None, catch_errors=True):
+        '''Wait for core to shutdown (e.g. through quit() or terminate()).'''
+        try:
+            self.wait_for_event(None, timeout=timeout, catch_errors=catch_errors)
+        except ShutdownError:
+            return
+
+    def _set_error_handler(self, future):
+        @self.event_callback('shutdown', 'queue-overflow')
+        def shutdown_handler(event):
+            nonlocal future
+            try:
+                if event.event_id.value == MpvEventID.SHUTDOWN:
+                    future.set_exception(ShutdownError('libmpv core has been shutdown'))
+                else:
+                    future.set_exception(EventOverflowError('libmpv event queue has flown over because events have not been processed fast enough'))
+            except InvalidStateError:
+                pass
+        return shutdown_handler.unregister_mpv_events
+
+    @contextmanager
+    def prepare_and_wait_for_property(self, name, cond=lambda val: val, level_sensitive=True, timeout=None, catch_errors=True):
+        """Context manager that waits until ``cond`` evaluates to a truthy value on the named property. See
+        prepare_and_wait_for_event for usage.
+        Raises a ShutdownError when the core is shutdown while waiting. Re-raises any errors inside ``cond``.
+        """
+        result = Future()
+
+        def observer(name, val):
+            try:
+                rv = cond(val)
+                if rv:
+                    result.set_result(rv)
+
+            except InvalidStateError:
+                pass
+
+            except Exception as e:
+                try:
+                    result.set_exception(e)
+                except:
+                    pass
+
+        try:
+            result.set_running_or_notify_cancel()
+
+            self.observe_property(name, observer)
+            err_unregister = self._set_error_handler(result)
+            if catch_errors:
+                self._exception_futures.add(result)
+
+            yield result
+
+            if level_sensitive:
+                rv = cond(getattr(self, name.replace('-', '_')))
+                if rv:
+                    result.set_result(rv)
+                    return
+
+            self.check_core_alive()
+            result.result(timeout)
+
+        except InvalidStateError:
+            pass
+
+        finally:
+            err_unregister()
+            self.unobserve_property(name, observer)
+            self._exception_futures.discard(result)
+
+    def wait_for_event(self, *event_types, cond=lambda evt: True, timeout=None, catch_errors=True):
+        """Waits for the indicated event(s). If cond is given, waits until cond(event) is true. Raises a ShutdownError
+        if the core is shutdown while waiting. This also happens when 'shutdown' is in event_types. Re-raises any error
+        inside ``cond``.
+        """
+        with self.prepare_and_wait_for_event(*event_types, cond=cond, timeout=timeout, catch_errors=catch_errors) as result:
+            pass
+        return result.result()
+
+    @contextmanager
+    def prepare_and_wait_for_event(self, *event_types, cond=lambda evt: True, timeout=None, catch_errors=True):
+        """Context manager that waits for the indicated event(s) like wait_for_event after running. If cond is given,
+        waits until cond(event) is true. Raises a ShutdownError if the core is shutdown while waiting. This also happens
+        when 'shutdown' is in event_types. Re-raises any error inside ``cond``.
+
+        Compared to wait_for_event this handles the case where a thread waits for an event it itself causes in a
+        thread-safe way. An example from the testsuite is:
+
+        with self.m.prepare_and_wait_for_event('client_message'):
+            self.m.keypress(key)
+
+        Using just wait_for_event it would be impossible to ensure the event is caught since it may already have been
+        handled in the interval between keypress(...) running and a subsequent wait_for_event(...) call.
+        """
+        result = Future()
+
+        @self.event_callback(*event_types)
+        def target_handler(evt):
+            try:
+                rv = cond(evt)
+                if rv:
+                    result.set_result(rv)
+            except Exception as e:
+                try:
+                    result.set_exception(e)
+                except InvalidStateError:
+                    pass
+            except InvalidStateError:
+                pass
+
+        err_unregister = self._set_error_handler(result)
+
+        try:
+            result.set_running_or_notify_cancel()
+            if catch_errors:
+                self._exception_futures.add(result)
+
+            yield result
+
+            self.check_core_alive()
+            result.result(timeout)
+
+        finally:
+            err_unregister()
+            target_handler.unregister_mpv_events()
+            self._exception_futures.discard(result)
+
+    def __del__(self):
+        if self.handle:
+            self.terminate()
+
+    def terminate(self):
+        """Properly terminates this player instance. Preferably use this instead of relying on python's garbage
+        collector to cause this to be called from the object's destructor.
+
+        This method will detach the main libmpv handle and wait for mpv to shut down and the event thread to finish.
+        """
+        self.handle, handle = None, self.handle
+        if threading.current_thread() is self._event_thread:
+            raise UserWarning('terminate() should not be called from event thread (e.g. from a callback function). If '
+                    'you want to terminate mpv from here, please call quit() instead, then sync the main thread '
+                    'against the event thread using e.g. wait_for_shutdown(), then terminate() from the main thread. '
+                    'This call has been transformed into a call to quit().')
+            self.quit()
+        else:
+            _mpv_terminate_destroy(handle)
+            if self._event_thread:
+                self._event_thread.join()
+
+    def set_loglevel(self, level):
+        """Set MPV's log level. This adjusts which output will be sent to this object's log handlers. If you just want
+        mpv's regular terminal output, you don't need to adjust this but just need to pass a log handler to the MPV
+        constructur such as ``MPV(log_handler=print)``.
+
+        Valid log levels are "no", "fatal", "error", "warn", "info", "v" "debug" and "trace". For details see your mpv's
+        client.h header file.
+        """
+        _mpv_request_log_messages(self._event_handle, level.encode('utf-8'))
+
+    def string_command(self, name, *args):
+        """Execute a raw command."""
+        args = _create_null_term_cmd_arg_array(name, args)
+        _mpv_command(self.handle, args)
+
+    def command_async(self, name, *args, callback=None, decoder=lazy_decoder, **kwargs):
+        """Same as mpv_command, but run the command asynchronously. If you provide a callback, that callback will be
+        called after completion or on error. This method returns a future that evaluates to the result of the callback
+        (if given), and the result of the libmpv call otherwise.
+
+        Usage example:
+
+            future = player.command_async(...)
+            try:
+                print('The result was', future.result())
+            except Exception as e:
+                print('mpv returned an error:', e)
+        """
+
+        future = Future()
+        future.set_running_or_notify_cancel()
+
+        if callback is None:
+            def callback(error, result):
+                if error:
+                    raise error
+                return result
+
+        def wrapper(error, result):
+            try:
+                result = result.unpack(decoder)
+                future.set_result(callback(error, result))
+            except Exception as e:
+                try:
+                    future.set_exception(e)
+                except InvalidStateError:
+                    pass
+
+        def abort():
+            _mpv_abort_async_command(self._event_handle, id(future))
+            del self._command_reply_callbacks[id(future)]
+        future.cancel = abort
+
+        self._command_reply_callbacks[id(future)] = wrapper
+
+        if kwargs:
+            if args:
+                raise ValueError('Can only call mpv commands either using positional or using named arguments, not a mix of both.')
+            kwargs['name'] = name
+            _1, _2, _3, pointer = _make_node_str_map(kwargs)
+        else:
+            _1, _2, _3, pointer = _make_node_str_list([name, *args])
+
+        ppointer = cast(pointer, POINTER(MpvNode))
+        _mpv_command_node_async(self._event_handle, id(future), ppointer)
+        return future
+
+
+    def node_command(self, name, *args, decoder=strict_decoder):
+        self.command(name, *args, decoder=decoder)
+
+    def command(self, name, *args, decoder=strict_decoder, **kwargs):
+        if kwargs:
+            if args:
+                raise ValueError('Can only call mpv commands either using positional or using named arguments, not a mix of both.')
+            kwargs['name'] = name
+            _1, _2, _3, pointer = _make_node_str_map(kwargs)
+        else:
+            _1, _2, _3, pointer = _make_node_str_list([name, *args])
+
+        out = cast(create_string_buffer(sizeof(MpvNode)), POINTER(MpvNode))
+        ppointer = cast(pointer, POINTER(MpvNode))
+        _mpv_command_node(self.handle, ppointer, out)
+        rv = out.contents.node_value(decoder=decoder)
+        _mpv_free_node_contents(out)
+        return rv
+
+    def seek(self, amount, reference="relative", precision="keyframes"):
+        """Mapped mpv seek command, see man mpv(1)."""
+        self.command('seek', amount, reference, precision)
+
+    def revert_seek(self):
+        """Mapped mpv revert_seek command, see man mpv(1)."""
+        self.command('revert_seek');
+
+    def frame_step(self):
+        """Mapped mpv frame-step command, see man mpv(1)."""
+        self.command('frame-step')
+
+    def frame_back_step(self):
+        """Mapped mpv frame_back_step command, see man mpv(1)."""
+        self.command('frame_back_step')
+
+    def property_add(self, name, value=1):
+        """Add the given value to the property's value. On overflow or underflow, clamp the property to the maximum. If
+        ``value`` is omitted, assume ``1``.
+        """
+        self.command('add', name, value)
+
+    def property_multiply(self, name, factor):
+        """Multiply the value of a property with a numeric factor."""
+        self.command('multiply', name, factor)
+
+    def cycle(self, name, direction='up'):
+        """Cycle the given property. ``up`` and ``down`` set the cycle direction. On overflow, set the property back to
+        the minimum, on underflow set it to the maximum. If ``up`` or ``down`` is omitted, assume ``up``.
+        """
+        self.command('cycle', name, direction)
+
+    def screenshot(self, includes='subtitles', mode='single'):
+        """Mapped mpv screenshot command, see man mpv(1)."""
+        self.command('screenshot', includes, mode)
+
+    def screenshot_to_file(self, filename, includes='subtitles'):
+        """Mapped mpv screenshot_to_file command, see man mpv(1)."""
+        self.command('screenshot_to_file', filename.encode(fs_enc), includes)
+
+    def screenshot_raw(self, includes='subtitles'):
+        """Mapped mpv screenshot_raw command, see man mpv(1). Returns a pillow Image object."""
+        from PIL import Image
+        res = self.command('screenshot-raw', includes)
+        if res['format'] != 'bgr0':
+            raise ValueError('Screenshot in unknown format "{}". Currently, only bgr0 is supported.'
+                    .format(res['format']))
+        img = Image.frombytes('RGBA', (res['stride']//4, res['h']), res['data'])
+        b,g,r,a = img.split()
+        return Image.merge('RGB', (r,g,b))
+
+    def allocate_overlay_id(self):
+        free_ids = set(range(64)) - self.overlay_ids
+        if not free_ids:
+            raise IndexError('All overlay IDs are in use')
+        next_id, *_ = sorted(free_ids)
+        self.overlay_ids.add(next_id)
+        return next_id
+
+    def free_overlay_id(self, overlay_id):
+        self.overlay_ids.remove(overlay_id)
+
+    def create_file_overlay(self, filename=None, size=None, stride=None, pos=(0,0)):
+        overlay_id = self.allocate_overlay_id()
+        overlay = FileOverlay(self, overlay_id, filename, size, stride, pos)
+        self.overlays[overlay_id] = overlay
+        return overlay
+
+    def create_image_overlay(self, img=None, pos=(0,0)):
+        overlay_id = self.allocate_overlay_id()
+        overlay = ImageOverlay(self, overlay_id, img, pos)
+        self.overlays[overlay_id] = overlay
+        return overlay
+
+    def remove_overlay(self, overlay_id):
+        self.overlay_remove(overlay_id)
+        self.free_overlay_id(overlay_id)
+        del self.overlays[overlay_id]
+
+    def playlist_next(self, mode='weak'):
+        """Mapped mpv playlist_next command, see man mpv(1)."""
+        self.command('playlist_next', mode)
+
+    def playlist_prev(self, mode='weak'):
+        """Mapped mpv playlist_prev command, see man mpv(1)."""
+        self.command('playlist_prev', mode)
+
+    def playlist_play_index(self, idx):
+        """Mapped mpv playlist-play-index command, see man mpv(1)."""
+        self.command('playlist-play-index', idx)
+
+    @staticmethod
+    def _encode_options(options):
+        return ','.join('{}={}'.format(_py_to_mpv(str(key)), str(val)) for key, val in options.items())
+
+    def loadfile(self, filename, mode='replace', index=None, **options):
+        """Mapped mpv loadfile command, see man mpv(1)."""
+        if self.mpv_version_tuple >= (0, 38, 0):
+            if index is None:
+                index = -1
+            self.command('loadfile', filename.encode(fs_enc), mode, index, MPV._encode_options(options))
+        else:
+            if index is not None:
+                warn(f'The index argument to the loadfile command is only supported on mpv >= 0.38.0')
+            self.command('loadfile', filename.encode(fs_enc), mode, MPV._encode_options(options))
+
+    def loadlist(self, playlist, mode='replace'):
+        """Mapped mpv loadlist command, see man mpv(1)."""
+        self.command('loadlist', playlist.encode(fs_enc), mode)
+
+    def playlist_clear(self):
+        """Mapped mpv playlist_clear command, see man mpv(1)."""
+        self.command('playlist_clear')
+
+    def playlist_remove(self, index='current'):
+        """Mapped mpv playlist_remove command, see man mpv(1)."""
+        self.command('playlist_remove', index)
+
+    def playlist_move(self, index1, index2):
+        """Mapped mpv playlist_move command, see man mpv(1)."""
+        self.command('playlist_move', index1, index2)
+
+    def playlist_shuffle(self):
+        """Mapped mpv playlist-shuffle command, see man mpv(1)."""
+        self.command('playlist-shuffle')
+
+    def playlist_unshuffle(self):
+        """Mapped mpv playlist-unshuffle command, see man mpv(1)."""
+        self.command('playlist-unshuffle')
+
+    def run(self, command, *args):
+        """Mapped mpv run command, see man mpv(1)."""
+        self.command('run', command, *args)
+
+    def quit(self, code=None):
+        """Mapped mpv quit command, see man mpv(1)."""
+        if code is not None:
+            self.command('quit', code)
+        else:
+            self.command('quit')
+
+    def quit_watch_later(self, code=None):
+        """Mapped mpv quit_watch_later command, see man mpv(1)."""
+        if code is not None:
+            self.command('quit_watch_later', code)
+        else:
+            self.command('quit_watch_later')
+
+    def stop(self, keep_playlist=False):
+        """Mapped mpv stop command, see man mpv(1)."""
+        if keep_playlist:
+            self.command('stop', 'keep-playlist')
+        else:
+            self.command('stop')
+
+    def audio_add(self, url, flags='select', title=None, lang=None):
+        """Mapped mpv audio_add command, see man mpv(1)."""
+        self.command('audio_add', url.encode(fs_enc), *_drop_nones(flags, title, lang))
+
+    def audio_remove(self, audio_id=None):
+        """Mapped mpv audio_remove command, see man mpv(1)."""
+        self.command('audio_remove', audio_id)
+
+    def audio_reload(self, audio_id=None):
+        """Mapped mpv audio_reload command, see man mpv(1)."""
+        self.command('audio_reload', audio_id)
+
+    def video_add(self, url, flags='select', title=None, lang=None, albumart=None):
+        """Mapped mpv video_add command, see man mpv(1)."""
+        self.command('video_add', url.encode(fs_enc), *_drop_nones(flags, title, lang, albumart))
+
+    def video_remove(self, video_id=None):
+        """Mapped mpv video_remove command, see man mpv(1)."""
+        self.command('video_remove', video_id)
+
+    def video_reload(self, video_id=None):
+        """Mapped mpv video_reload command, see man mpv(1)."""
+        self.command('video_reload', video_id)
+
+    def sub_add(self, url, flags='select', title=None, lang=None):
+        """Mapped mpv sub_add command, see man mpv(1)."""
+        self.command('sub_add', url.encode(fs_enc), *_drop_nones(flags, title, lang))
+
+    def sub_remove(self, sub_id=None):
+        """Mapped mpv sub_remove command, see man mpv(1)."""
+        self.command('sub_remove', sub_id)
+
+    def sub_reload(self, sub_id=None):
+        """Mapped mpv sub_reload command, see man mpv(1)."""
+        self.command('sub_reload', sub_id)
+
+    def sub_step(self, skip):
+        """Mapped mpv sub_step command, see man mpv(1)."""
+        self.command('sub_step', skip)
+
+    def sub_seek(self, skip):
+        """Mapped mpv sub_seek command, see man mpv(1)."""
+        self.command('sub_seek', skip)
+
+    def toggle_osd(self):
+        """Mapped mpv osd command, see man mpv(1)."""
+        self.command('osd')
+
+    def print_text(self, text):
+        """Mapped mpv print-text command, see man mpv(1)."""
+        self.command('print-text', text)
+
+    def show_text(self, string, duration='-1', level=0):
+        """Mapped mpv show_text command, see man mpv(1)."""
+        self.command('show_text', string, duration, level)
+
+    def expand_text(self, text):
+        """Mapped mpv expand-text command, see man mpv(1)."""
+        return self.command('expand-text', text)
+
+    def expand_path(self, path):
+        """Mapped mpv expand-path command, see man mpv(1)."""
+        return self.command('expand-path', path)
+
+    def show_progress(self):
+        """Mapped mpv show_progress command, see man mpv(1)."""
+        self.command('show_progress')
+
+    def rescan_external_files(self, mode='reselect'):
+        """Mapped mpv rescan-external-files command, see man mpv(1)."""
+        self.command('rescan-external-files', mode)
+
+    def discnav(self, command):
+        """Mapped mpv discnav command, see man mpv(1)."""
+        self.command('discnav', command)
+
+    def mouse(self, x, y, button=None, mode='single'):
+        """Mapped mpv mouse command, see man mpv(1)."""
+        if button is None:
+            self.command('mouse', x, y, mode)
+        else:
+            self.command('mouse', x, y, button, mode)
+
+    def keypress(self, name):
+        """Mapped mpv keypress command, see man mpv(1)."""
+        self.command('keypress', name)
+
+    def keydown(self, name):
+        """Mapped mpv keydown command, see man mpv(1)."""
+        self.command('keydown', name)
+
+    def keyup(self, name=None):
+        """Mapped mpv keyup command, see man mpv(1)."""
+        if name is None:
+            self.command('keyup')
+        else:
+            self.command('keyup', name)
+
+    def keybind(self, name, command):
+        """Mapped mpv keybind command, see man mpv(1)."""
+        self.command('keybind', name, command)
+
+    def write_watch_later_config(self):
+        """Mapped mpv write_watch_later_config command, see man mpv(1)."""
+        self.command('write_watch_later_config')
+
+    def overlay_add(self, overlay_id, x, y, file_or_fd, offset, fmt, w, h, stride):
+        """Mapped mpv overlay_add command, see man mpv(1)."""
+        self.command('overlay_add', overlay_id, x, y, file_or_fd, offset, fmt, w, h, stride)
+
+    def overlay_remove(self, overlay_id):
+        """Mapped mpv overlay_remove command, see man mpv(1)."""
+        self.command('overlay_remove', overlay_id)
+
+    def osd_overlay(self, overlay_id, data, res_x=0, res_y=720, z=0, hidden=False):
+        self.command('osd_overlay', id=overlay_id, data=data, res_x=res_x, res_y=res_Y, z=z, hidden=hidden,
+        format='ass-events')
+
+    def osd_overlay_remove(self, overlay_id):
+        self.command('osd_overlay', id=overlay_id, format='none')
+
+    def script_message(self, *args):
+        """Mapped mpv script_message command, see man mpv(1)."""
+        self.command('script_message', *args)
+
+    def script_message_to(self, target, *args):
+        """Mapped mpv script_message_to command, see man mpv(1)."""
+        self.command('script_message_to', target, *args)
+
+    def drop_buffers(self):
+        self.command('drop_buffers')
+
+    def vf_command(self, label, command, argument):
+        self.command('vf_command', label, command, argument)
+
+    def af_command(self, label, command, argument):
+        self.command('af_command', label, command, argument)
+
+    def observe_property(self, name, handler):
+        """Register an observer on the named property. An observer is a function that is called with the new property
+        value every time the property's value is changed. The basic function signature is ``fun(property_name,
+        new_value)`` with new_value being the decoded property value as a python object. This function can be used as a
+        function decorator if no handler is given.
+
+        To unregister the observer, call either of ``mpv.unobserve_property(name, handler)``,
+        ``mpv.unobserve_all_properties(handler)`` or the handler's ``unobserve_mpv_properties`` attribute::
+
+            @player.property_observer('volume')
+            def my_handler(property_name, new_volume):
+                print("It's loud!", new_volume)
+
+            my_handler.unobserve_mpv_properties()
+
+        exit_handler is a function taking no arguments that is called when the underlying mpv handle is terminated (e.g.
+        from calling MPV.terminate() or issuing a "quit" input command).
+        """
+        self._property_handlers[name].append(handler)
+        _mpv_observe_property(self._event_handle, hash(name)&0xffffffffffffffff, name.encode('utf-8'), MpvFormat.NODE)
+
+    def property_observer(self, name):
+        """Function decorator to register a property observer. See ``MPV.observe_property`` for details."""
+        def wrapper(fun):
+            self.observe_property(name, fun)
+            fun.unobserve_mpv_properties = lambda: self.unobserve_property(name, fun)
+            return fun
+        return wrapper
+
+    def unobserve_property(self, name, handler):
+        """Unregister a property observer. This requires both the observed property's name and the handler function that
+        was originally registered as one handler could be registered for several properties. To unregister a handler
+        from *all* observed properties see ``unobserve_all_properties``.
+        """
+        self._property_handlers[name].remove(handler)
+        if not self._property_handlers[name]:
+            _mpv_unobserve_property(self._event_handle, hash(name)&0xffffffffffffffff)
+
+    def unobserve_all_properties(self, handler):
+        """Unregister a property observer from *all* observed properties."""
+        for name in self._property_handlers:
+            self.unobserve_property(name, handler)
+
+    def register_message_handler(self, target, handler=None):
+        """Register a mpv script message handler. This can be used to communicate with embedded lua scripts. Pass the
+        script message target name this handler should be listening to and the handler function.
+
+        WARNING: Only one handler can be registered at a time for any given target.
+
+        To unregister the message handler, call its ``unregister_mpv_messages`` function::
+
+            player = mpv.MPV()
+            @player.message_handler('foo')
+            def my_handler(some, args):
+                print(args)
+
+            my_handler.unregister_mpv_messages()
+        """
+        self._register_message_handler_internal(target, handler)
+
+    def _register_message_handler_internal(self, target, handler):
+        self._message_handlers[target] = handler
+
+    def unregister_message_handler(self, target_or_handler):
+        """Unregister a mpv script message handler for the given script message target name.
+
+        You can also call the ``unregister_mpv_messages`` function attribute set on the handler function when it is
+        registered.
+        """
+        if isinstance(target_or_handler, str):
+            del self._message_handlers[target_or_handler]
+        else:
+            for key, val in self._message_handlers.items():
+                if val == target_or_handler:
+                    del self._message_handlers[key]
+
+    def message_handler(self, target):
+        """Decorator to register a mpv script message handler.
+
+        WARNING: Only one handler can be registered at a time for any given target.
+
+        To unregister the message handler, call its ``unregister_mpv_messages`` function::
+
+            player = mpv.MPV()
+            @player.message_handler('foo')
+            def my_handler(some, args):
+                print(args)
+
+            my_handler.unregister_mpv_messages()
+        """
+        def register(handler):
+            self._register_message_handler_internal(target, handler)
+            handler.unregister_mpv_messages = lambda: self.unregister_message_handler(handler)
+            return handler
+        return register
+
+    def register_event_callback(self, callback):
+        """Register a blanket event callback receiving all event types.
+
+        To unregister the event callback, call its ``unregister_mpv_events`` function::
+
+            player = mpv.MPV()
+            @player.event_callback('shutdown')
+            def my_handler(event):
+                print('It ded.')
+
+            my_handler.unregister_mpv_events()
+        """
+        self._event_callbacks.append(callback)
+
+    def unregister_event_callback(self, callback):
+        """Unregiser an event callback."""
+        self._event_callbacks.remove(callback)
+
+    def event_callback(self, *event_types):
+        """Function decorator to register a blanket event callback for the given event types. Event types can be given
+        as str (e.g.  'start-file'), integer or MpvEventID object.
+
+        WARNING: Due to the way this is filtering events, this decorator cannot be chained with itself.
+
+        To unregister the event callback, call its ``unregister_mpv_events`` function::
+
+            player = mpv.MPV()
+            @player.event_callback('shutdown')
+            def my_handler(event):
+                print('It ded.')
+
+            my_handler.unregister_mpv_events()
+        """
+        def register(callback):
+            with self._event_handler_lock:
+                self.check_core_alive()
+                types = [MpvEventID.from_str(t) if isinstance(t, str) else t for t in event_types] or MpvEventID.ANY
+                @wraps(callback)
+                def wrapper(event, *args, **kwargs):
+                    if event.event_id.value in types:
+                        callback(event, *args, **kwargs)
+                self._event_callbacks.append(wrapper)
+                wrapper.unregister_mpv_events = partial(self.unregister_event_callback, wrapper)
+                return wrapper
+        return register
+
+    @staticmethod
+    def _binding_name(callback_or_cmd):
+        return 'py_kb_{:016x}'.format(hash(callback_or_cmd)&0xffffffffffffffff)
+
+    def on_key_press(self, keydef, mode='force', repetition=False):
+        """Function decorator to register a simplified key binding. The callback is called whenever the key given is
+        *pressed*. When the ``repetition=True`` is passed, the callback is called again repeatedly while the key is held
+        down.
+
+        To unregister the callback function, you can call its ``unregister_mpv_key_bindings`` attribute::
+
+            player = mpv.MPV()
+            @player.on_key_press('Q')
+            def binding():
+                print('blep')
+
+            binding.unregister_mpv_key_bindings()
+
+        WARNING: For a single keydef only a single callback/command can be registered at the same time. If you register
+        a binding multiple times older bindings will be overwritten and there is a possibility of references leaking. So
+        don't do that.
+
+        The BIG FAT WARNING regarding untrusted keydefs from the key_binding method applies here as well.
+        """
+        def register(fun):
+            @self.key_binding(keydef, mode)
+            @wraps(fun)
+            def wrapper(state='p-', name=None, char=None, *_):
+                if state[0] in ('d', 'p') or (repetition and state[0] == 'r'):
+                    fun()
+            return wrapper
+        return register
+
+    def key_binding(self, keydef, mode='force'):
+        """Function decorator to register a low-level key binding.
+
+        The callback function signature is ``fun(key_state, key_name, key_char, scale, arg)``.
+
+        The key_state contains up to three chars, corresponding to the regex ``[udr]([m-][c-]?)?``. ``[udr]`` means
+        "key up", "key down", or "repetition" for when the key is held down. "m" indicates mouse events, and "c"
+        indicates key up events resulting from a logical cancellation. For details check out the mpv man page.
+
+        The keydef format is: ``[Shift+][Ctrl+][Alt+][Meta+]<key>`` where ``<key>`` is either the literal character the
+        key produces (ASCII or Unicode character), or a symbolic name (as printed by ``mpv --input-keylist``).
+
+        To unregister the callback function, you can call its ``unregister_mpv_key_bindings`` attribute::
+
+            player = mpv.MPV()
+            @player.key_binding('Q')
+            def binding(state, name, char):
+                print('blep')
+
+            binding.unregister_mpv_key_bindings()
+
+        WARNING: For a single keydef only a single callback/command can be registered at the same time. If you register
+        a binding multiple times older bindings will be overwritten and there is a possibility of references leaking. So
+        don't do that.
+
+        BIG FAT WARNING: mpv's key binding mechanism is pretty powerful.  This means, you essentially get arbitrary code
+        exectution through key bindings. This interface makes some limited effort to sanitize the keydef given in the
+        first parameter, but YOU SHOULD NOT RELY ON THIS IN FOR SECURITY. If your input comes from config files, this is
+        completely fine--but, if you are about to pass untrusted input into this parameter, better double-check whether
+        this is secure in your case.
+        """
+        def register(fun):
+            fun.mpv_key_bindings = getattr(fun, 'mpv_key_bindings', []) + [keydef]
+            def unregister_all():
+                for keydef in fun.mpv_key_bindings:
+                    self.unregister_key_binding(keydef)
+            fun.unregister_mpv_key_bindings = unregister_all
+
+            self.register_key_binding(keydef, fun, mode)
+            return fun
+        return register
+
+    def register_key_binding(self, keydef, callback_or_cmd, mode='force'):
+        """Register a key binding. This takes an mpv keydef and either a string containing a mpv command or a python
+        callback function.  See ``MPV.key_binding`` for details.
+        """
+        if not re.match(r'(Shift+)?(Ctrl+)?(Alt+)?(Meta+)?(.|\w+)', keydef):
+            raise ValueError('Invalid keydef. Expected format: [Shift+][Ctrl+][Alt+][Meta+]<key>\n'
+                    '<key> is either the literal character the key produces (ASCII or Unicode character), or a '
+                    'symbolic name (as printed by --input-keylist')
+        binding_name = MPV._binding_name(keydef)
+        if callable(callback_or_cmd):
+            self._key_binding_handlers[binding_name] = callback_or_cmd
+            self.register_message_handler('key-binding', self._handle_key_binding_message)
+            self.command('define-section',
+                    binding_name, '{} script-binding py_event_handler/{}'.format(keydef, binding_name), mode)
+        elif isinstance(callback_or_cmd, str):
+            self.command('define-section', binding_name, '{} {}'.format(keydef, callback_or_cmd), mode)
+        else:
+            raise TypeError('register_key_binding expects either an str with an mpv command or a python callable.')
+        self.command('enable-section', binding_name, 'allow-hide-cursor+allow-vo-dragging')
+
+    def _handle_key_binding_message(self, binding_name, key_state, key_name=None, key_char=None, scale=None, arg=None, *_):
+        binding_name = binding_name.decode('utf-8')
+        key_state = key_state.decode('utf-8')
+        key_name = key_name.decode('utf-8') if key_name is not None else None
+        key_char = key_char.decode('utf-8') if key_char is not None else None
+        self._key_binding_handlers[binding_name](key_state, key_name, key_char, scale, arg)
+
+    def unregister_key_binding(self, keydef):
+        """Unregister a key binding by keydef."""
+        binding_name = MPV._binding_name(keydef)
+        self.command('disable-section', binding_name)
+        self.command('define-section', binding_name, '')
+        if binding_name in self._key_binding_handlers:
+            del self._key_binding_handlers[binding_name]
+            if not self._key_binding_handlers:
+                self.unregister_message_handler('key-binding')
+
+    def register_stream_protocol(self, proto, open_fn=None):
+        """ Register a custom stream protocol as documented in libmpv/stream_cb.h:
+            https://github.com/mpv-player/mpv/blob/master/libmpv/stream_cb.h
+
+            proto is the protocol scheme, e.g. "foo" for "foo://" urls.
+
+            This function can either be used with two parameters or it can be used as a decorator on the target
+            function.
+
+            open_fn is a function taking an URI string and returning an mpv stream object.
+            open_fn may raise a ValueError to signal libmpv the URI could not be opened.
+
+            The mpv stream protocol is as follows:
+            class Stream:
+                @property
+                def size(self):
+                    return None # unknown size
+                    return size # int with size in bytes
+
+                def read(self, size):
+                    ...
+                    return read # non-empty bytes object with input
+                    return b'' # empty byte object signals permanent EOF
+
+                def seek(self, pos): # optional
+                    return new_offset # integer with new byte offset. The new offset may be before the requested offset
+                    in case an exact seek is inconvenient.
+
+                def close(self): # optional
+                    ...
+
+                def cancel(self): # optional
+                    Abort a running read() or seek() operation
+                    ...
+
+        """
+
+        def decorator(open_fn):
+            @StreamOpenFn
+            def open_backend(_userdata, uri, cb_info):
+                try:
+                    frontend = open_fn(uri.decode('utf-8'))
+                except ValueError:
+                    return ErrorCode.LOADING_FAILED
+                except Exception as e:
+                    for fut in self._exception_futures:
+                        try:
+                            fut.set_exception(e)
+                            break
+                        except InvalidStateError:
+                            pass
+                    else:
+                        warnings.warn(f'Unhandled exception {e} inside stream open callback for URI {uri}\n{traceback.format_exc()}')
+                    return ErrorCode.LOADING_FAILED
+
+                cb_info.contents.cookie = None
+
+                def read_backend(_userdata, buf, bufsize):
+                    with self._enqueue_exceptions():
+                        data = frontend.read(bufsize)
+                        for i in range(len(data)):
+                            buf[i] = data[i]
+                        return len(data)
+                    return -1
+                read = cb_info.contents.read = StreamReadFn(read_backend)
+
+                def close_backend(_userdata):
+                    with self._enqueue_exceptions():
+                        del self._stream_protocol_frontends[proto][uri]
+                        if hasattr(frontend, 'close'):
+                            frontend.close()
+                close = cb_info.contents.close = StreamCloseFn(close_backend)
+
+                seek, size, cancel = None, None, None
+
+                if hasattr(frontend, 'seek'):
+                    def seek_backend(_userdata, offx):
+                        with self._enqueue_exceptions():
+                            return frontend.seek(offx)
+                        return ErrorCode.GENERIC
+                    seek = cb_info.contents.seek = StreamSeekFn(seek_backend)
+
+                if hasattr(frontend, 'size') and frontend.size is not None:
+                    def size_backend(_userdata):
+                        with self._enqueue_exceptions():
+                            return frontend.size
+                        return 0
+                    size = cb_info.contents.size = StreamSizeFn(size_backend)
+
+                if hasattr(frontend, 'cancel'):
+                    def cancel_backend(_userdata):
+                        with self._enqueue_exceptions():
+                            frontend.cancel()
+                    cancel = cb_info.contents.cancel = StreamCancelFn(cancel_backend)
+
+                # keep frontend and callbacks in memory until closed
+                frontend._registered_callbacks = [read, close, seek, size, cancel]
+                self._stream_protocol_frontends[proto][uri] = frontend
+                return 0
+
+            if proto in self._stream_protocol_cbs:
+                raise KeyError('Stream protocol already registered')
+            # keep backend in memory forever
+            self._stream_protocol_cbs[proto] = [open_backend]
+            _mpv_stream_cb_add_ro(self.handle, proto.encode('utf-8'), c_void_p(), open_backend)
+
+            return open_fn
+
+        if open_fn is not None:
+            decorator(open_fn)
+        return decorator
+
+    # Convenience functions
+    def play(self, filename):
+        """Play a path or URL (requires ``ytdl`` option to be set)."""
+        self.loadfile(filename)
+
+    @property
+    def playlist_filenames(self):
+        """Return all playlist item file names/URLs as a list of strs."""
+        return [element['filename'] for element in self.playlist]
+
+    def playlist_append(self, filename, **options):
+        """Append a path or URL to the playlist. This does not start playing the file automatically. To do that, use
+        ``MPV.loadfile(filename, 'append-play')``."""
+        self.loadfile(filename, 'append', **options)
+
+    # "Python stream" logic. This is some porcelain for directly playing data from python generators.
+
+    def _python_stream_open(self, uri):
+        """Internal handler for python:// protocol streams registered through @python_stream(...) and
+        @python_stream_catchall
+        """
+        name, = re.fullmatch('python://(.*)', uri).groups()
+
+        if name in self._python_streams:
+            generator_fun, size = self._python_streams[name]
+        else:
+            if self._python_stream_catchall is not None:
+                generator_fun, size = self._python_stream_catchall(name)
+            else:
+                raise ValueError('Python stream name not found and no catch-all defined')
+
+        return GeneratorStream(generator_fun, size)
+
+    def python_stream(self, name=None, size=None):
+        """Register a generator for the python stream with the given name.
+
+        name is the name, i.e. the part after the "python://" in the URI, that this generator is registered as.
+        size is the total number of bytes in the stream (if known).
+
+        Any given name can only be registered once. The catch-all can also only be registered once. To unregister a
+        stream, call the .unregister function set on the callback.
+
+        If name is None (the default), a name and corresponding python:// URI are automatically generated. You can
+        access the name through the .stream_name property set on the callback, and the stream URI for passing into
+        mpv.play(...) through the .stream_uri property.
+
+        The generator signals EOF by returning, manually raising StopIteration or by yielding b'', an empty bytes
+        object.
+
+        The generator may be called multiple times if libmpv seeks or loops.
+
+        See also: @mpv.python_stream_catchall
+
+        @mpv.python_stream('foobar')
+        def reader():
+            for chunk in chunks:
+                yield chunk
+        mpv.play('python://foobar')
+        mpv.wait_for_playback()
+        reader.unregister()
+        """
+        def register(cb):
+            nonlocal name
+            if name is None:
+                name = f'__python_mpv_anonymous_python_stream_{id(cb)}__'
+
+            if name in self._python_streams:
+                raise KeyError('Python stream name "{}" is already registered'.format(name))
+
+            self._python_streams[name] = (cb, size)
+            def unregister():
+                if name not in self._python_streams or\
+                        self._python_streams[name][0] is not cb: # This is just a basic sanity check
+                    raise RuntimeError('Python stream has already been unregistered')
+                del self._python_streams[name]
+
+            cb.unregister = unregister
+            cb.stream_name = name
+            cb.stream_uri = f'python://{name}'
+            return cb
+
+        return register
+
+    @contextmanager
+    def play_context(self):
+        """ Context manager for streaming bytes straight into libmpv.
+
+        This is a convenience wrapper around python_stream. play_context returns a write method, which you can use in
+        the body of the context manager to feed libmpv bytes. All bytes you feed in with write() in the body of a single
+        call of this context manager are treated as one single file. A queue is used internally, so this function is
+        thread-safe. The queue is unlimited, so it cannot block and is safe to call from async code. You can use this
+        function to stream chunked data, e.g. from the network.
+
+        Use it like this:
+
+        with m.play_context() as write:
+            with open(TESTVID, 'rb') as f:
+                while (chunk := f.read(65536)): # Get some chunks of bytes
+                    write(chunk)
+        """
+        q = queue.Queue()
+
+        EOF = object() # Get some unique object as EOF marker
+        @self.python_stream()
+        def reader():
+            while (chunk := q.get()) is not EOF:
+                if chunk:
+                    yield chunk
+            reader.unregister()
+
+        def write(chunk):
+            q.put(chunk)
+
+        # Start playback before yielding, the first call to reader() will block until write is called at least once.
+        self.play(reader.stream_uri)
+        yield write
+        q.put(EOF)
+
+    def play_bytes(self, data):
+        """ Play the given bytes object as a single file. """
+
+        @self.python_stream()
+        def reader():
+            yield data
+            reader.unregister() # unregister itself
+
+        self.play(reader.stream_uri)
+
+    def python_stream_catchall(self, cb):
+        """ Register a catch-all python stream to be called when no name matches can be found. Use this decorator on a
+        function that takes a name argument and returns a (generator, size) tuple (with size being None if unknown).
+
+        An invalid URI can be signalled to libmpv by raising a ValueError inside the callback.
+
+        See also: @mpv.python_stream(name, size)
+
+        @mpv.python_stream_catchall
+        def catchall(name):
+            if not name.startswith('foo'):
+                raise ValueError('Unknown Name')
+
+            def foo_reader():
+                with open(name, 'rb') as f:
+                    while True:
+                        chunk = f.read(1024)
+                        if not chunk:
+                            break
+                        yield chunk
+            return foo_reader, None
+        mpv.play('python://foo23')
+        mpv.wait_for_playback()
+        catchall.unregister()
+        """
+        if self._python_stream_catchall is not None:
+            raise KeyError('A catch-all python stream is already registered')
+
+        self._python_stream_catchall = cb
+        def unregister():
+            if self._python_stream_catchall is not cb:
+                    raise RuntimeError('This catch-all python stream has already been unregistered')
+            self._python_stream_catchall = None
+        cb.unregister = unregister
+        return cb
+
+    # Property accessors
+    def _get_property(self, name, decoder=strict_decoder, fmt=MpvFormat.NODE):
+        self.check_core_alive()
+        out = create_string_buffer(sizeof(MpvNode))
+        try:
+            cval = _mpv_get_property(self.handle, name.encode('utf-8'), fmt, out)
+
+            if fmt is MpvFormat.OSD_STRING:
+                return cast(out, POINTER(c_char_p)).contents.value.decode('utf-8')
+            elif fmt is MpvFormat.NODE:
+                rv = cast(out, POINTER(MpvNode)).contents.node_value(decoder=decoder)
+                _mpv_free_node_contents(out)
+                return rv
+            else:
+                raise TypeError('_get_property only supports NODE and OSD_STRING formats.')
+        except PropertyUnavailableError as ex:
+            return None
+
+    def _set_property(self, name, value):
+        self.check_core_alive()
+        ename = name.encode('utf-8')
+        if isinstance(value, dict):
+            _1, _2, _3, pointer = _make_node_str_map(value)
+            _mpv_set_property(self.handle, ename, MpvFormat.NODE, pointer)
+        elif isinstance(value, (list, set)):
+            _1, _2, _3, pointer = _make_node_str_list(value)
+            _mpv_set_property(self.handle, ename, MpvFormat.NODE, pointer)
+        else:
+            _mpv_set_property_string(self.handle, ename, _mpv_coax_proptype(value))
+
+    def __getattr__(self, name):
+        return self._get_property(_py_to_mpv(name), lazy_decoder)
+
+    def __setattr__(self, name, value):
+            try:
+                if name != 'handle' and not name.startswith('_'):
+                    self._set_property(_py_to_mpv(name), value)
+                else:
+                    super().__setattr__(name, value)
+            except AttributeError:
+                super().__setattr__(name, value)
+
+    def __dir__(self):
+        return super().__dir__() + [ name.replace('-', '_') for name in self.property_list ]
+
+    @property
+    def properties(self):
+        return { name: self.option_info(name) for name in self.property_list }
+
+    # Dict-like option access
+    def __getitem__(self, name, file_local=False):
+        """Get an option value."""
+        prefix = 'file-local-options/' if file_local else 'options/'
+        return self._get_property(prefix+name, lazy_decoder)
+
+    def __setitem__(self, name, value, file_local=False):
+        """Set an option value."""
+        prefix = 'file-local-options/' if file_local else 'options/'
+        return self._set_property(prefix+name, value)
+
+    def __iter__(self):
+        """Iterate over all option names."""
+        return iter(self.options)
+
+    def option_info(self, name):
+        """Get information on the given option."""
+        try:
+            return self._get_property('option-info/'+name)
+        except AttributeError:
+            return None
+
+
+class MpvRenderContext:
+    def __init__(self, mpv, api_type, **kwargs):
+        self._mpv = mpv
+        kwargs['api_type'] = api_type
+
+        buf = cast(create_string_buffer(sizeof(MpvRenderCtxHandle)), POINTER(MpvRenderCtxHandle))
+        _mpv_render_context_create(buf, mpv.handle, kwargs_to_render_param_array(kwargs))
+        self._handle = buf.contents
+
+    def free(self):
+        _mpv_render_context_free(self._handle)
+
+    def __setattr__(self, name, value):
+        if name.startswith('_'):
+            super().__setattr__(name, value)
+
+        elif name == 'update_cb':
+            func = value if value else (lambda: None)
+            self._update_cb = value
+            self._update_fn_wrapper = RenderUpdateFn(lambda _userdata: func())
+            _mpv_render_context_set_update_callback(self._handle, self._update_fn_wrapper, None)
+
+        else:
+            param = MpvRenderParam(name, value)
+            _mpv_render_context_set_parameter(self._handle, param)
+
+    def __getattr__(self, name):
+        if name == 'update_cb':
+            return self._update_cb
+
+        elif name == 'handle':
+            return self._handle
+
+        param = MpvRenderParam(name)
+        data_type = type(param.data.contents)
+        buf = cast(create_string_buffer(sizeof(data_type)), POINTER(data_type))
+        param.data = buf
+        _mpv_render_context_get_info(self._handle, param)
+        return buf.contents.as_dict()
+
+    def update(self):
+        """ Calls mpv_render_context_update and returns the MPV_RENDER_UPDATE_FRAME flag (see render.h) """
+        return bool(_mpv_render_context_update(self._handle) & 1)
+
+    def render(self, **kwargs):
+        _mpv_render_context_render(self._handle, kwargs_to_render_param_array(kwargs))
+
+    def report_swap(self):
+        _mpv_render_context_report_swap(self._handle)
+
diff --git a/defl/unitFormat_.py b/defl/unitFormat_.py
new file mode 100644
index 0000000..c6f80e0
--- /dev/null
+++ b/defl/unitFormat_.py
@@ -0,0 +1,84 @@
+import math
+from dataclasses import KW_ONLY, dataclass
+from ._typing_ import *
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class UnitFormatSystem:
+    units: dict[str, int | float]
+    richColor: dict[str, tuple[str, str]]
+    ansiColor: dict[str, tuple[str, str]]
+
+
+bytesUnitFormat = UnitFormatSystem(
+    units={'B': 1024, 'K': 1024, 'M': 1024, 'G': 1024, 'T': 1024, 'P': 1024},
+    richColor={
+        'B': ('[green]', '[/green]'),
+        'K': ('[magenta]', '[/magenta]'),
+        'M': ('[yellow]', '[/yellow]'),
+        'G': ('[orange]', '[/orange]'),
+        'T': ('[red]', '[/red]'),
+        'P': ('[white]', '[/white]'),
+    },
+    ansiColor={
+        'B': (cl.grn, cl.r),
+        'K': (cl.mag, cl.r),
+        'M': (cl.yel, cl.r),
+        'G': (cl.org, cl.r),
+        'T': (cl.red, cl.r),
+        'P': (cl.wht, cl.r),
+    },
+)
+thousandsUnitFormat = UnitFormatSystem(
+    units={'': 1024, 'e^1': 1024, 'e^2': 1024, 'e^3': 1024, 'e^4': 1024, 'e^5': 1024},
+    richColor={
+        '': ('[green]', '[/green]'),
+        'e^1': ('[magenta]', '[/magenta]'),
+        'e^2': ('[yellow]', '[/yellow]'),
+        'e^3': ('[orange]', '[/orange]'),
+        'e^4': ('[red]', '[/red]'),
+        'e^5': ('[white]', '[/white]'),
+    },
+    ansiColor={
+        '': (cl.grn, cl.r),
+        'e^1': (cl.mag, cl.r),
+        'e^2': (cl.yel, cl.r),
+        'e^3': (cl.org, cl.r),
+        'e^4': (cl.red, cl.r),
+        'e^5': (cl.wht, cl.r),
+    },
+)
+
+
+class UnitFormatColor(defl.Enumer):
+    Rich = enum.auto()
+    Ansi = enum.auto()
+    Null = enum.auto()
+
+
+@dataclass(slots=T, kw_only=T, frozen=F)
+class UnitFormat:
+    system: UnitFormatSystem
+    color: UnitFormatColor = UnitFormatColor.Null
+    fmt: str = '{colStart}{mag:,.2f}{unit}{colEnd}'
+
+    def human(_, mag: int | float) -> tuple[str]:
+        names = tuple(_.system.units.keys())
+        conv = tuple(_.system.units.values())
+        i = 0
+        while i + 1 < len(conv) and (nxt := mag / conv[i]) > 1:
+            i += 1
+            mag = nxt
+        key = names[i]
+        match _.color:
+            case UnitFormatColor.Rich:
+                colStart, colEnd = (_.system.richColor.get(key)[0], _.system.richColor.get(key)[1])
+            case UnitFormatColor.Ansi:
+                colStart, colEnd = (_.system.ansiColor.get(key)[0], _.system.ansiColor.get(key)[1])
+            case UnitFormatColor.Null:
+                colStart, colEnd = ('', '')
+            case __:
+                raise NotImplementedError(f'no match for {_.color}')
+        if inst(_.fmt, str) or callable(_.fmt):
+            return _.fmt(mag=mag, unit=names[i], colStart=colStart, colEnd=colEnd)
+        return dict(mag=mag, unit=names[i], colStart=colStart, colEnd=colEnd)
diff --git a/pyproject.toml b/pyproject.toml
index 34ec8a2..5ea699b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -60,7 +60,6 @@ dependencies = [
     # "pynput", # keyboard/mouse macro
     'toml>=0',
     'urllib3>=0',
-    'dash>=0',
     'pydantic==2.9.1',
     'pydantic-core==2.23.3',
     'pydantic-settings==2.6.1',
@@ -69,6 +68,7 @@ dependencies = [
     # https://code.visualstudio.com/docs/python/debugging
     # https://github.com/microsoft/debugpy/
     # 'debugpy>=0',
+    'pytest>=0',
 ]
 description = "Dog's Extra Function Library"
 name = "defl"
@@ -84,6 +84,7 @@ personal = [
     "alpaca-py>=0",
     # alpaca broker automated trading
     "opencv-python>=0",
+    'dash>=0',
 ]
 
 [build-system]
diff --git a/tests.old/importTime.sh b/tests.old/importTime.sh
new file mode 100644
index 0000000..66317f9
--- /dev/null
+++ b/tests.old/importTime.sh
@@ -0,0 +1,5 @@
+time python -c 'import sys'
+time python -c 'for i in range(9_999_999):import sys'
+
+# (1.264-.07)/9_999_999
+# 1.1940001194000118e-07
diff --git a/tests/lint.sh b/tests.old/lint.sh
similarity index 100%
rename from tests/lint.sh
rename to tests.old/lint.sh
diff --git a/tests/markdown.txt b/tests.old/markdown.txt
similarity index 100%
rename from tests/markdown.txt
rename to tests.old/markdown.txt
diff --git a/tests/template b/tests.old/template
similarity index 100%
rename from tests/template
rename to tests.old/template
diff --git a/tests/test_action.py b/tests.old/test_action.py
similarity index 100%
rename from tests/test_action.py
rename to tests.old/test_action.py
diff --git a/tests/test_argparse.py b/tests.old/test_argparse.py
similarity index 100%
rename from tests/test_argparse.py
rename to tests.old/test_argparse.py
diff --git a/tests/test_argparse2.py b/tests.old/test_argparse2.py
similarity index 100%
rename from tests/test_argparse2.py
rename to tests.old/test_argparse2.py
diff --git a/tests/test_assert.py b/tests.old/test_assert.py
similarity index 100%
rename from tests/test_assert.py
rename to tests.old/test_assert.py
diff --git a/tests/test_basic.py b/tests.old/test_basic.py
similarity index 100%
rename from tests/test_basic.py
rename to tests.old/test_basic.py
diff --git a/tests/test_bytes.py b/tests.old/test_bytes.py
similarity index 100%
rename from tests/test_bytes.py
rename to tests.old/test_bytes.py
diff --git a/tests/test_checkType.py b/tests.old/test_checkType.py
similarity index 100%
rename from tests/test_checkType.py
rename to tests.old/test_checkType.py
diff --git a/tests/test_classes.py b/tests.old/test_classes.py
similarity index 100%
rename from tests/test_classes.py
rename to tests.old/test_classes.py
diff --git a/tests/test_cliWrap.py b/tests.old/test_cliWrap.py
similarity index 100%
rename from tests/test_cliWrap.py
rename to tests.old/test_cliWrap.py
diff --git a/tests/test_clipboard.py b/tests.old/test_clipboard.py
similarity index 100%
rename from tests/test_clipboard.py
rename to tests.old/test_clipboard.py
diff --git a/tests/test_configFormats.py b/tests.old/test_configFormats.py
similarity index 100%
rename from tests/test_configFormats.py
rename to tests.old/test_configFormats.py
diff --git a/tests/test_dataclass.py b/tests.old/test_dataclass.py
similarity index 100%
rename from tests/test_dataclass.py
rename to tests.old/test_dataclass.py
diff --git a/tests/test_decorators.py b/tests.old/test_decorators.py
similarity index 100%
rename from tests/test_decorators.py
rename to tests.old/test_decorators.py
diff --git a/tests/test_deflmidi.py b/tests.old/test_deflmidi.py
similarity index 100%
rename from tests/test_deflmidi.py
rename to tests.old/test_deflmidi.py
diff --git a/tests/test_fzf.py b/tests.old/test_fzf.py
similarity index 100%
rename from tests/test_fzf.py
rename to tests.old/test_fzf.py
diff --git a/tests/test_generator.py b/tests.old/test_generator.py
similarity index 100%
rename from tests/test_generator.py
rename to tests.old/test_generator.py
diff --git a/tests/test_inspect.py b/tests.old/test_inspect.py
similarity index 100%
rename from tests/test_inspect.py
rename to tests.old/test_inspect.py
diff --git a/tests.old/test_jq.py b/tests.old/test_jq.py
new file mode 100755
index 0000000..ec99d99
--- /dev/null
+++ b/tests.old/test_jq.py
@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+
+import json
+from defl.testing_ import Tester, Test, TestState
+from dataclasses import dataclass, field, KW_ONLY
+import sys
+import re, io
+import os
+import enum
+import itertools
+from functools import partial, partialmethod
+from time import sleep
+from operator import itemgetter
+from defl import log, cl, Undefined, Null, Assert, Obj, JqLoad, Dath
+from defl import CLIError
+from defl._typing_ import *
+from defl._pydantic_ import *
+from defl._typing_ import false, true, none
+import defl
+
+log.setLevel('i')
+tester = Tester(name=__file__)
+
+
+@tester.add()
+def toJson():
+    r = []
+    a = b'{"a":9,"b":[1,2,3],"c":{"a":{"b":1,"c":{"a":1},"d":{"a":2}},"d":[{"a":3},{"a":4}]}}\n'
+    jl = JqLoad()
+    r.extend(jl.send(a))
+    r.extend(jl.res())
+    Assert(r).eq(
+        [{'a': 9, 'b': [1, 2, 3], 'c': {'a': {'b': 1, 'c': {'a': 1}, 'd': {'a': 2}}, 'd': [{'a': 3}, {'a': 4}]}}]
+    )
+
+
+@tester.add()
+def toJson():
+    r = []
+    a = b"""
+    {"a":1}\n
+    {"a":2}\n
+    {"a":3}\n
+    """
+    jl = JqLoad()
+    r.extend(jl.send(a))
+    r.extend(jl.res())
+    Assert(r).eq([{'a': 1}, {'a': 2}, {'a': 3}])
+
+
+@tester.add()
+def toJson():
+    r = []
+    a = b"""
+    {"a":1}\n
+    {"a"
+    """
+    jl = JqLoad()
+    r.extend(jl.send(a))
+    a = jl.res()
+    Assert(next(a)) == {'a': 1}
+    try:
+        next(a)
+        raise NotImplementedError('dont get here')
+    except defl.JqError:
+        ...
+
+
+data = """
+        {     "name": "sda",     "maj:min": "8:0",     "rm": false,     "size": "476.9G",     "ro": false,     "type": "disk"  }
+    {   "name": "sda1",   "maj:min": "8:1",   "rm": false,   "size": "512M",   "ro": false,   "type": "part"}
+    {
+        "name": "sda2",         "maj:min": "8:2",         "rm": false,
+        "size": "476.4G",         "ro": false,         "type": "part"
+    }
+    {
+        "name": "",         "maj:min": "254:0",
+        "rm": false,         "size": "476.4G",         "ro": false,         "type": "crypt"      }
+    {
+        "name": "-swap",
+        "maj:min": "254:1",
+        "rm": false,
+        "size": "8G",
+        "ro": false,
+        "type": "lvm"
+    }
+    {"name":
+
+
+
+
+    "-root","maj:min":"254:2","rm":false,"size":"32G","ro":false,"type":"lvm"}
+
+
+
+    {         "name": "-home",
+        "maj:min": "254:3",
+        "rm": false,         "size": "436.4G",
+        "ro": false,
+        "type": "lvm"      }
+
+"""
+
+equ = [
+    {'name': 'sda', 'maj:min': '8:0', 'rm': False, 'size': '476.9G', 'ro': False, 'type': 'disk'},
+    {'name': 'sda1', 'maj:min': '8:1', 'rm': False, 'size': '512M', 'ro': False, 'type': 'part'},
+    {'name': 'sda2', 'maj:min': '8:2', 'rm': False, 'size': '476.4G', 'ro': False, 'type': 'part'},
+    {'name': '', 'maj:min': '254:0', 'rm': False, 'size': '476.4G', 'ro': False, 'type': 'crypt'},
+    {'name': '-swap', 'maj:min': '254:1', 'rm': False, 'size': '8G', 'ro': False, 'type': 'lvm'},
+    {'name': '-root', 'maj:min': '254:2', 'rm': False, 'size': '32G', 'ro': False, 'type': 'lvm'},
+    {'name': '-home', 'maj:min': '254:3', 'rm': False, 'size': '436.4G', 'ro': False, 'type': 'lvm'},
+]
+
+
+@tester.add()
+def toJsonLoad():
+    a = io.BytesIO(data.encode())
+    Assert([x for x in JqLoad().fromFile(a)]).eq(equ)
+
+    a = io.BytesIO(data.encode())
+    Assert([x for x in JqLoad().fromFile(a, amnt=2)]).eq(equ)
+
+
+@tester.add()
+def toJsonSave():
+    tmp = Dath.Temp().tempFile(autoRemove=T)
+
+    with defl.JqDump(output=tmp) as d:
+        for i in equ:
+            d.dump(i)
+    t = tmp.read_text().split('\n')
+    Assert(t) == [
+        '{"name":"sda","maj:min":"8:0","rm":false,"size":"476.9G","ro":false,"type":"disk"}',
+        '{"name":"sda1","maj:min":"8:1","rm":false,"size":"512M","ro":false,"type":"part"}',
+        '{"name":"sda2","maj:min":"8:2","rm":false,"size":"476.4G","ro":false,"type":"part"}',
+        '{"name":"","maj:min":"254:0","rm":false,"size":"476.4G","ro":false,"type":"crypt"}',
+        '{"name":"-swap","maj:min":"254:1","rm":false,"size":"8G","ro":false,"type":"lvm"}',
+        '{"name":"-root","maj:min":"254:2","rm":false,"size":"32G","ro":false,"type":"lvm"}',
+        '{"name":"-home","maj:min":"254:3","rm":false,"size":"436.4G","ro":false,"type":"lvm"}',
+        '',
+    ]
+
+
+@tester.add()
+def pydant():
+    @dantClass()
+    class A:
+        a: int
+        b: list['A'] | N = N
+
+    a = A(a=1, b=(A(a=2), A(a=3)))
+    for i in [
+        '__pydantic_complete__',
+        '__pydantic_config__',
+        '__pydantic_core_schema__',
+        '__pydantic_decorators__',
+        '__pydantic_fields__',
+        '__pydantic_serializer__',
+        '__pydantic_validator__',
+    ]:
+        print(i, getattr(a, i))
+    a = defl.jsonReprDump(a)
+    Assert(a) == {'a': 1, 'b': [{'a': 2, 'b': None}, {'a': 3, 'b': None}]}
+
+
+log.info(tester.run())
+tester.exitWithStatus()
diff --git a/tests/test_logging.py b/tests.old/test_logging.py
similarity index 100%
rename from tests/test_logging.py
rename to tests.old/test_logging.py
diff --git a/tests/test_lsblk.py b/tests.old/test_lsblk.py
similarity index 100%
rename from tests/test_lsblk.py
rename to tests.old/test_lsblk.py
diff --git a/tests/test_math.py b/tests.old/test_math.py
similarity index 100%
rename from tests/test_math.py
rename to tests.old/test_math.py
diff --git a/tests/test_microlang.py b/tests.old/test_microlang.py
similarity index 100%
rename from tests/test_microlang.py
rename to tests.old/test_microlang.py
diff --git a/tests/test_midi.py b/tests.old/test_midi.py
similarity index 100%
rename from tests/test_midi.py
rename to tests.old/test_midi.py
diff --git a/tests/test_networking.py b/tests.old/test_networking.py
similarity index 100%
rename from tests/test_networking.py
rename to tests.old/test_networking.py
diff --git a/tests/test_obj.py b/tests.old/test_obj.py
similarity index 100%
rename from tests/test_obj.py
rename to tests.old/test_obj.py
diff --git a/tests/test_overloaded.py b/tests.old/test_overloaded.py
similarity index 100%
rename from tests/test_overloaded.py
rename to tests.old/test_overloaded.py
diff --git a/tests/test_overrider.py b/tests.old/test_overrider.py
similarity index 100%
rename from tests/test_overrider.py
rename to tests.old/test_overrider.py
diff --git a/tests/test_pass.py b/tests.old/test_pass.py
similarity index 100%
rename from tests/test_pass.py
rename to tests.old/test_pass.py
diff --git a/tests/test_path.py b/tests.old/test_path.py
similarity index 83%
rename from tests/test_path.py
rename to tests.old/test_path.py
index 4463d6f..1418603 100755
--- a/tests/test_path.py
+++ b/tests.old/test_path.py
@@ -1,16 +1,16 @@
 #!/usr/bin/env python
-'''
+"""
 onFileChange.py ~/deflDev/tests/test_path.py ~/deflDev/defl/_path_.py -- ~/deflDev/bin/pythonDeflDev.py - python ~/deflDev/tests/test_path.py
 
 time find >/dev/null
 time python3 -c 'import pathlib;pathlib.Path("**/*")'
-'''
+"""
 
 import defl
 import os
 import shlex
 import pathlib
-from defl import log, cl, Path
+from defl import log, cl, Path, Dath, sp
 from defl.testing_ import Tester
 
 tester = Tester(name=__file__)
@@ -20,10 +20,21 @@ def msg(a, b):
     return f'{cl.yel}{a=}{cl.r} {cl.mag}{b=}{cl.r}'
 
 
+@tester.add()
+def test():
+    assert Dath('a') == Dath('a')
+
+
+@tester.add()
+def test():
+    print(sp.tmp, type(sp.tmp))
+    assert isinstance(sp.tmp, Dath)
+
+
 @tester.add()
 def test1():
     a = str(Path('~'))
-    b = str(pathlib.Path("~"))
+    b = str(pathlib.Path('~'))
     assert a != b, msg(a, b)
 
 
@@ -125,12 +136,12 @@ def makeTestFiles():
         defl.RunCom('rm -rf /tmp/pathTest')
     for i in 'abc':
         for j in '123':
-            forceTouchAndAddToCreated(pathTestRoot / i / f"file_{i}_{j}")
-            forceTouchAndAddToCreated(pathTestRoot / i / j / f"file_{i}_{j}")
-            forceTouchAndAddToCreated(pathTestRoot / i / j / f"linkDir_{i}_{j}", link='/tmp/pathTest')
+            forceTouchAndAddToCreated(pathTestRoot / i / f'file_{i}_{j}')
+            forceTouchAndAddToCreated(pathTestRoot / i / j / f'file_{i}_{j}')
+            forceTouchAndAddToCreated(pathTestRoot / i / j / f'linkDir_{i}_{j}', link='/tmp/pathTest')
             forceTouchAndAddToCreated(
-                pathTestRoot / i / j / f"linkFile_{i}_{j}",
-                link=pathTestRoot / i / j / f"file_{i}_{j}")
+                pathTestRoot / i / j / f'linkFile_{i}_{j}', link=pathTestRoot / i / j / f'file_{i}_{j}'
+            )
     assert len(createdDirs) == 13
     assert len(createdFiles) == 18
     assert len(createdLinks) == 18
@@ -147,6 +158,7 @@ def toCompile():
         assert isinstance(a, list)
         for i in a:
             assert isinstance(i, re.Pattern)
+
     ass(defl.castRegexList(None), l=0)
     ass(defl.castRegexList('a'), l=1)
     ass(defl.castRegexList(['a']), l=1)
@@ -173,7 +185,7 @@ def pathfilter1():
         t = [x for x in pr.find(defl.PathFilter(**args))]
         t = sorted(t)
         t = [x.str for x in t]
-        assert len(t) == assCount, f"{cl.red}{args}{cl.r} ({cl.red}{len(t)}{cl.r}!={cl.grn}{assCount}{cl.r}): {t}"
+        assert len(t) == assCount, f'{cl.red}{args}{cl.r} ({cl.red}{len(t)}{cl.r}!={cl.grn}{assCount}{cl.r}): {t}'
 
     argsAssert(18, file=True)
     argsAssert(6, file=True, test=[lambda x: re.compile(r'/file_._3$').search(str(x))])
@@ -192,15 +204,30 @@ def pathfilter1():
 
     with pathTestRoot.chdirCM():
         res = Path('.').find(
-            pathFilter=defl.PathFilter(file=True, link=True, test=[
-                defl.regSearchFactory('linkDir_'), '|',
-                defl.regSearchFactory('linkFile_'), '|',
-                defl.regSearchFactory('a|b'), '|', None
-            ]),
-            descendDirFilter=['!', defl.regSearchFactory('^b/')]
+            pathFilter=defl.PathFilter(
+                file=True,
+                link=True,
+                test=[
+                    defl.regSearchFactory('linkDir_'),
+                    '|',
+                    defl.regSearchFactory('linkFile_'),
+                    '|',
+                    defl.regSearchFactory('a|b'),
+                    '|',
+                    None,
+                ],
+            ),
+            descendDirFilter=['!', defl.regSearchFactory('^b/')],
         )
         res = sorted([str(x) for x in res])
-        assert res == ['a/1/linkFile_a_1', 'a/2/linkFile_a_2', 'a/3/linkFile_a_3', 'c/1/linkFile_c_1', 'c/2/linkFile_c_2', 'c/3/linkFile_c_3'], res
+        assert res == [
+            'a/1/linkFile_a_1',
+            'a/2/linkFile_a_2',
+            'a/3/linkFile_a_3',
+            'c/1/linkFile_c_1',
+            'c/2/linkFile_c_2',
+            'c/3/linkFile_c_3',
+        ], res
 
 
 def parts():
diff --git a/tests/test_pathUtils.py b/tests.old/test_pathUtils.py
similarity index 100%
rename from tests/test_pathUtils.py
rename to tests.old/test_pathUtils.py
diff --git a/tests/test_popenTime.py b/tests.old/test_popenTime.py
similarity index 100%
rename from tests/test_popenTime.py
rename to tests.old/test_popenTime.py
diff --git a/tests/test_pydantic.py b/tests.old/test_pydantic.py
similarity index 100%
rename from tests/test_pydantic.py
rename to tests.old/test_pydantic.py
diff --git a/tests/test_random.py b/tests.old/test_random.py
similarity index 100%
rename from tests/test_random.py
rename to tests.old/test_random.py
diff --git a/tests/test_regex.py b/tests.old/test_regex.py
similarity index 100%
rename from tests/test_regex.py
rename to tests.old/test_regex.py
diff --git a/tests/test_rsync.py b/tests.old/test_rsync.py
similarity index 100%
rename from tests/test_rsync.py
rename to tests.old/test_rsync.py
diff --git a/tests/test_run.py b/tests.old/test_run.py
similarity index 100%
rename from tests/test_run.py
rename to tests.old/test_run.py
diff --git a/tests/test_runcom.py b/tests.old/test_runcom.py
similarity index 100%
rename from tests/test_runcom.py
rename to tests.old/test_runcom.py
diff --git a/tests/test_sheet.py b/tests.old/test_sheet.py
similarity index 100%
rename from tests/test_sheet.py
rename to tests.old/test_sheet.py
diff --git a/tests/test_shellQuote.py b/tests.old/test_shellQuote.py
similarity index 100%
rename from tests/test_shellQuote.py
rename to tests.old/test_shellQuote.py
diff --git a/tests/test_sound.py b/tests.old/test_sound.py
similarity index 100%
rename from tests/test_sound.py
rename to tests.old/test_sound.py
diff --git a/tests/test_sqllite.py b/tests.old/test_sqllite.py
similarity index 100%
rename from tests/test_sqllite.py
rename to tests.old/test_sqllite.py
diff --git a/tests/test_string.py b/tests.old/test_string.py
similarity index 100%
rename from tests/test_string.py
rename to tests.old/test_string.py
diff --git a/tests/test_system.py b/tests.old/test_system.py
similarity index 100%
rename from tests/test_system.py
rename to tests.old/test_system.py
diff --git a/tests/test_table.py b/tests.old/test_table.py
similarity index 100%
rename from tests/test_table.py
rename to tests.old/test_table.py
diff --git a/tests/test_tester.py b/tests.old/test_tester.py
similarity index 100%
rename from tests/test_tester.py
rename to tests.old/test_tester.py
diff --git a/tests/test_thread.py b/tests.old/test_thread.py
similarity index 100%
rename from tests/test_thread.py
rename to tests.old/test_thread.py
diff --git a/tests/test_threadPool.py b/tests.old/test_threadPool.py
similarity index 100%
rename from tests/test_threadPool.py
rename to tests.old/test_threadPool.py
diff --git a/tests/test_time.py b/tests.old/test_time.py
similarity index 100%
rename from tests/test_time.py
rename to tests.old/test_time.py
diff --git a/tests/test_timeit.py b/tests.old/test_timeit.py
similarity index 100%
rename from tests/test_timeit.py
rename to tests.old/test_timeit.py
diff --git a/tests/test_tree.py b/tests.old/test_tree.py
similarity index 100%
rename from tests/test_tree.py
rename to tests.old/test_tree.py
diff --git a/tests/test_userIn.py b/tests.old/test_userIn.py
similarity index 100%
rename from tests/test_userIn.py
rename to tests.old/test_userIn.py
diff --git a/tests/_template b/tests/_template
new file mode 100644
index 0000000..acbe1b9
--- /dev/null
+++ b/tests/_template
@@ -0,0 +1,102 @@
+import pytest
+
+# def test_001(): 
+# def test_002(): 
+# def test_003(): 
+# def test_004(): 
+# def test_005(): 
+# def test_006(): 
+# def test_007(): 
+# def test_008(): 
+# def test_009(): 
+# def test_010(): 
+# def test_011(): 
+# def test_012(): 
+# def test_013(): 
+# def test_014(): 
+# def test_015(): 
+# def test_016(): 
+# def test_017(): 
+# def test_018(): 
+# def test_019(): 
+# def test_020(): 
+# def test_021(): 
+# def test_022(): 
+# def test_023(): 
+# def test_024(): 
+# def test_025(): 
+# def test_026(): 
+# def test_027(): 
+# def test_028(): 
+# def test_029(): 
+# def test_030(): 
+# def test_031(): 
+# def test_032(): 
+# def test_033(): 
+# def test_034(): 
+# def test_035(): 
+# def test_036(): 
+# def test_037(): 
+# def test_038(): 
+# def test_039(): 
+# def test_040(): 
+# def test_041(): 
+# def test_042(): 
+# def test_043(): 
+# def test_044(): 
+# def test_045(): 
+# def test_046(): 
+# def test_047(): 
+# def test_048(): 
+# def test_049(): 
+# def test_050(): 
+# def test_051(): 
+# def test_052(): 
+# def test_053(): 
+# def test_054(): 
+# def test_055(): 
+# def test_056(): 
+# def test_057(): 
+# def test_058(): 
+# def test_059(): 
+# def test_060(): 
+# def test_061(): 
+# def test_062(): 
+# def test_063(): 
+# def test_064(): 
+# def test_065(): 
+# def test_066(): 
+# def test_067(): 
+# def test_068(): 
+# def test_069(): 
+# def test_070(): 
+# def test_071(): 
+# def test_072(): 
+# def test_073(): 
+# def test_074(): 
+# def test_075(): 
+# def test_076(): 
+# def test_077(): 
+# def test_078(): 
+# def test_079(): 
+# def test_080(): 
+# def test_081(): 
+# def test_082(): 
+# def test_083(): 
+# def test_084(): 
+# def test_085(): 
+# def test_086(): 
+# def test_087(): 
+# def test_088(): 
+# def test_089(): 
+# def test_090(): 
+# def test_091(): 
+# def test_092(): 
+# def test_093(): 
+# def test_094(): 
+# def test_095(): 
+# def test_096(): 
+# def test_097(): 
+# def test_098(): 
+# def test_099(): 
+# def test_100(): 
diff --git a/tests/speed/run.sh b/tests/speed/run.sh
new file mode 100644
index 0000000..d82774b
--- /dev/null
+++ b/tests/speed/run.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+set -o errexit -o nounset -o pipefail
+eval "$@"
+scriptDir="$(cd "$(dirname $(readlink -f "${BASH_SOURCE[0]}"))" && pwd)"
+hostname="$(hostnamectl hostname)"
+
+pytest --durations=0 $scriptDir -v --capture=no
diff --git a/tests/speed/test_list.py b/tests/speed/test_list.py
new file mode 100644
index 0000000..1b1674e
--- /dev/null
+++ b/tests/speed/test_list.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+
+from collections import Counter
+import sys, re, os, enum, itertools, timeit
+from functools import partial, partialmethod
+from time import sleep
+from dataclasses import dataclass, field
+from operator import itemgetter
+from defl import log, cl, Dath, Time, Run, sp, ShQu
+from defl._typing_ import *
+from defl._typing_ import T, F, N, U
+from defl._rich_ import *
+from defl._pydantic_ import *
+import defl
+
+number = 500_000
+repeat = 5
+
+
+# == loop
+def test_loop_comprehension():
+    code = [
+        'output = []',
+        'lst1= [1, 3, 5, 7, 9, 11]',
+        'lst2=[2, 4, 6, 8, 10, 12]',
+        'output = [(a, b) for a in lst1 for b in lst2]',
+    ]
+    code = '\n'.join(code)
+    res = timeit.repeat(code, number=number, repeat=repeat)
+    res = sum(res) / len(res)
+    print(res)
+
+
+def test_loop_forLoop():
+    code = [
+        'output = []',
+        'lst1= [1, 3, 5, 7, 9, 11]',
+        'lst2=[2, 4, 6, 8, 10, 12]',
+        'for a in lst1:',
+        '    for b in lst2:',
+        '        output.extend((a, b))',
+    ]
+    code = '\n'.join(code)
+    res = timeit.repeat(code, number=number, repeat=repeat)
+    res = sum(res) / len(res)
+    print(res)
+
+
+# == concatinate
+
+
+def test_createList_declare():
+    code = [
+        'output = [1,2,4,5,6,7,8,9]',
+    ]
+    code = '\n'.join(code)
+    res = timeit.repeat(code, number=number, repeat=repeat)
+    res = sum(res) / len(res)
+    print(res)
+
+
+def test_createList_concatinate():
+    code = [
+        'output = [1,2] + [4,5] + [6,7] + [8,9]',
+    ]
+    code = '\n'.join(code)
+    res = timeit.repeat(code, number=number, repeat=repeat)
+    res = sum(res) / len(res)
+    print(res)
+
+
+def test_createList_unpack():
+    code = [
+        'output = [*[1,2], *[4,5], *[6,7], *[8,9]]',
+    ]
+    code = '\n'.join(code)
+    res = timeit.repeat(code, number=number, repeat=repeat)
+    res = sum(res) / len(res)
+    print(res)
+
+
+def test_createList_extend():
+    code = [
+        'output = []',
+        'output.extend([1,2])',
+        'output.extend([4,5])',
+        'output.extend([6,7])',
+        'output.extend([8,9])',
+    ]
+    code = '\n'.join(code)
+    res = timeit.repeat(code, number=number, repeat=repeat)
+    res = sum(res) / len(res)
+    print(res)
diff --git a/tests/test_dath.py b/tests/test_dath.py
new file mode 100755
index 0000000..db5c891
--- /dev/null
+++ b/tests/test_dath.py
@@ -0,0 +1,287 @@
+#!/usr/bin/env python
+
+from collections import Counter
+import sys, re, os, enum, itertools, shlex
+from functools import partial, partialmethod
+from time import sleep
+from dataclasses import dataclass, field
+from operator import itemgetter
+from defl import log, cl, Dath, Time, Run, sp, ShQu
+from defl._typing_ import *
+from defl._typing_ import T, F, N, U
+from defl._rich_ import *
+from defl._pydantic_ import *
+import defl
+from pathlib import Path as PLPath
+from defl._path._temp_ import TempPath
+
+import pytest
+
+
+def test_001(): ...
+
+
+def test_002():
+    a = Dath('a')
+    assert isinstance(a._path, PLPath)
+
+
+def test_003():
+    @dataclass(slots=T, kw_only=T, frozen=F)
+    class A:
+        a: Dath
+
+    a = A(a=Dath('a'))
+    assert isinstance(a, A)
+    assert isinstance(a.a, Dath)
+    assert isinstance(a.a._path, PLPath)
+
+
+def test_004():
+    a = str(Dath('~'))
+    b = str(PLPath('~'))
+    assert a != b
+
+
+def test_005():
+    a = str(Dath('~'))
+    b = os.environ['HOME']
+    assert a == b
+
+
+def test_006():
+    p = '/a/b/c/d e'
+    a = shlex.quote(str(PLPath(p)))
+    b = Dath(p).quote()
+    assert a == b
+
+
+def test_007():
+    assert repr(Dath('a')) == Dath('a').__repr__() == 'λ(a)'
+
+
+def test_008():
+    a = str(Dath('a') / 'b/c/d/e')
+    b = 'a/b/c/d/e'
+    assert a == b
+
+
+def test_009():
+    Dath().is_file()
+    Dath().is_dir()
+
+
+def test_010():
+    a = Dath('/tmp/').chdir()
+    assert isinstance(a, Dath)
+    a = a.absolute().str
+    b = '/tmp'
+    assert a == b
+
+
+def test_012():
+    assert Dath('a') == PLPath('a')
+
+
+def test_013():
+    assert Dath('a') == Dath('a')
+
+
+def test_014():
+    assert (a := PLPath('/').parts) == ('/',), a
+    assert (a := Dath('/').parts) == ('/',), a
+    assert (a := (Dath('/') / 'aa/bb/').parts) == ('/', 'aa', 'bb'), a
+    assert (a := (Dath('/') / 'aa/bb').parts) == ('/', 'aa', 'bb'), a
+
+    assert (a := PLPath('.').parts) == (), a
+    assert (a := Dath('.').parts) == (), a
+    assert (a := (Dath('.') / 'aa/bb/').parts) == ('aa', 'bb'), a
+    assert (a := (Dath('.') / 'aa/bb').parts) == ('aa', 'bb'), a
+
+
+def test_015():
+    a = [
+        "Dath('/aa/bb/cc/')",
+        "Dath('/aa') / 'bb' / 'cc'",
+        "Dath('/aa') / 'bb/cc'",
+        "Dath('/') / 'aa/bb/cc'",
+        "Dath('/', 'aa', 'bb', 'cc')",
+        "Dath(['/', 'aa'], ['bb', 'cc'])",
+        "Dath('/', ['aa', 'bb'], 'cc')",
+        "Dath('/', 'aa/bb', ['cc'])",
+        "Dath('/aa/bb', ['cc'])",
+        "Dath('/aa/bb/cc', '')",
+        "Dath('/aa/bb/cc/', '')",
+        "Dath(['/', 'aa', 'bb', 'cc'])",
+        "Dath(['/', 'aa', 'bb', 'cc'], '///')",
+        "Dath(['///', 'aa', 'bb', 'cc'], '///')",
+        "Dath(tuple(['/', 'aa', 'bb', 'cc']))",
+    ]
+    for i in a:
+        ev = eval(i)
+        assert ev.parts == ('/', 'aa', 'bb', 'cc'), (i, ev.parts)
+
+
+def test_016():
+    a = [
+        "Dath('aa/bb/cc/')",
+        "Dath('aa', 'bb', 'cc')",
+        "Dath(tuple(['aa', 'bb', 'cc']))",
+    ]
+    for i in a:
+        ev = eval(i)
+        assert ev.parts == ('aa', 'bb', 'cc'), (i, ev.parts)
+
+
+def test_017():
+    a = [
+        "Dath(['00/11///22/33'])",
+        "Dath(['00'], '/11///22/33')",
+        "Dath(['00/11///22///33'])",
+        "Dath('00', '/', '11', '///', '/', '/', '/', '/', '/', '22', '/', '33')",
+        "Dath(['00', '/', '11', '/', '/', '/', '///', '///', '/', '22', '/', '33', '///'])",
+    ]
+    for i in a:
+        ev = eval(i)
+        assert ev.parts == ('00', '11', '22', '33'), (i, ev.parts)
+
+
+def test_018():
+    a = Dath('/00/a/22/33/00/b/22/33/00/c/22/33/00/d/22/33')
+    b = a.regFindIter('^.00/.*c/22')
+    assert [x for x in b][0].span() == (0, 30)
+    b = a.regFindIter('^(.*)$')
+    assert [x for x in b][0].span() == (0, 44)
+    b = a.regSub('^.00/?', '/')
+    assert str(b) == '/a/22/33/00/b/22/33/00/c/22/33/00/d/22/33'
+    b = a.regSub('.*/')
+    assert str(b) == '33'
+    b = a.regSearch('/22/33/00/b/22/33/00/c/22/33/00/d/22')
+    assert b
+
+
+def test_019():
+    @dantDC()
+    class A:
+        path: PLPath | Dath
+
+        @classmethod
+        def From(cls, path: Dath | PLPath) -> Self:
+            return cls(path=path)
+
+    a = A.From(path=Dath('a'))
+    assert inst(a.path, Dath)
+    with pytest.raises(AttributeError):
+        # | AttributeError: 'Dath' object has no attribute '_path'
+        a._path  # | TODO for some reason pydantic is not calling `Dath.__init__()`
+
+    a = A.From(path=PLPath('a'))
+    assert inst(a, A)
+    assert inst(a.path, PLPath)
+    b = Dath(a.path)
+    assert b._path == PLPath('a')
+
+
+def test_020():
+    tp = TempPath(path=Dath('/a/b/c/')).setExt('d').setName('e')
+    tpg = tp.generate()
+
+    tpg1 = next(tpg)
+    assert tpg1.parent == Dath('/a/b/c')
+    r = r'^e_[0-9]{6}[0-9]{6}.d'
+    assert re.search(r, tpg1.name), f'{tpg1.name} != {r}'
+
+    tpg2 = next(tpg)
+    assert tpg2.parent == Dath('/a/b/c')
+    r = r'^e_[0-9]{6}[0-9]{6}_00001.d'
+    assert re.search(r, tpg2.name), f'{tpg2.name} != {r}'
+
+
+def test_020():
+    with pytest.raises(TempPath.TempPathNoIndexInFmtError):
+        tp = TempPath(path=Dath('/a/b/c/'), fmt=[]).setExt('d').setName('e')
+
+
+def test_021():
+    defl.sp.tmp.makeTemp('a', autoRemove=T, create=F, direct=F)
+
+
+# def test_022():
+# def test_023():
+# def test_024():
+# def test_025():
+# def test_026():
+# def test_027():
+# def test_028():
+# def test_029():
+# def test_030():
+# def test_031():
+# def test_032():
+# def test_033():
+# def test_034():
+# def test_035():
+# def test_036():
+# def test_037():
+# def test_038():
+# def test_039():
+# def test_040():
+# def test_041():
+# def test_042():
+# def test_043():
+# def test_044():
+# def test_045():
+# def test_046():
+# def test_047():
+# def test_048():
+# def test_049():
+# def test_050():
+# def test_051():
+# def test_052():
+# def test_053():
+# def test_054():
+# def test_055():
+# def test_056():
+# def test_057():
+# def test_058():
+# def test_059():
+# def test_060():
+# def test_061():
+# def test_062():
+# def test_063():
+# def test_064():
+# def test_065():
+# def test_066():
+# def test_067():
+# def test_068():
+# def test_069():
+# def test_070():
+# def test_071():
+# def test_072():
+# def test_073():
+# def test_074():
+# def test_075():
+# def test_076():
+# def test_077():
+# def test_078():
+# def test_079():
+# def test_080():
+# def test_081():
+# def test_082():
+# def test_083():
+# def test_084():
+# def test_085():
+# def test_086():
+# def test_087():
+# def test_088():
+# def test_089():
+# def test_090():
+# def test_091():
+# def test_092():
+# def test_093():
+# def test_094():
+# def test_095():
+# def test_096():
+# def test_097():
+# def test_098():
+# def test_099():
+# def test_100():
diff --git a/tests/test_jq.py b/tests/test_jq.py
old mode 100755
new mode 100644
index ec99d99..3272e04
--- a/tests/test_jq.py
+++ b/tests/test_jq.py
@@ -1,167 +1,36 @@
 #!/usr/bin/env python
 
-import json
-from defl.testing_ import Tester, Test, TestState
-from dataclasses import dataclass, field, KW_ONLY
-import sys
-import re, io
-import os
-import enum
-import itertools
+from collections import Counter
+import sys, re, os, enum, itertools, shlex, io
 from functools import partial, partialmethod
 from time import sleep
+from dataclasses import dataclass, field
 from operator import itemgetter
-from defl import log, cl, Undefined, Null, Assert, Obj, JqLoad, Dath
-from defl import CLIError
+from defl import log, cl, Dath, Time, Run, sp, ShQu
 from defl._typing_ import *
+from defl._typing_ import T, F, N, U
+from defl._rich_ import *
 from defl._pydantic_ import *
-from defl._typing_ import false, true, none
 import defl
+from pathlib import Path as PLPath
+from defl._path._temp_ import TempPath
 
-log.setLevel('i')
-tester = Tester(name=__file__)
+import pytest
 
 
-@tester.add()
-def toJson():
-    r = []
-    a = b'{"a":9,"b":[1,2,3],"c":{"a":{"b":1,"c":{"a":1},"d":{"a":2}},"d":[{"a":3},{"a":4}]}}\n'
-    jl = JqLoad()
-    r.extend(jl.send(a))
-    r.extend(jl.res())
-    Assert(r).eq(
-        [{'a': 9, 'b': [1, 2, 3], 'c': {'a': {'b': 1, 'c': {'a': 1}, 'd': {'a': 2}}, 'd': [{'a': 3}, {'a': 4}]}}]
-    )
+def test_jqDump1():
+    tmpPath = defl.sp.tmp.makeTemp([], autoRemove=T, create=T, direct=F, ext=N)
+    with defl.JqDump(tmpPath, append=T) as jq:
+        for i in range(3):
+            jq.dump({'a': i})
+    res = tmpPath.readText()
+    assert res == '{"a":0}\n{"a":1}\n{"a":2}\n'
 
 
-@tester.add()
-def toJson():
-    r = []
-    a = b"""
-    {"a":1}\n
-    {"a":2}\n
-    {"a":3}\n
-    """
-    jl = JqLoad()
-    r.extend(jl.send(a))
-    r.extend(jl.res())
-    Assert(r).eq([{'a': 1}, {'a': 2}, {'a': 3}])
-
-
-@tester.add()
-def toJson():
-    r = []
-    a = b"""
-    {"a":1}\n
-    {"a"
-    """
-    jl = JqLoad()
-    r.extend(jl.send(a))
-    a = jl.res()
-    Assert(next(a)) == {'a': 1}
-    try:
-        next(a)
-        raise NotImplementedError('dont get here')
-    except defl.JqError:
-        ...
-
-
-data = """
-        {     "name": "sda",     "maj:min": "8:0",     "rm": false,     "size": "476.9G",     "ro": false,     "type": "disk"  }
-    {   "name": "sda1",   "maj:min": "8:1",   "rm": false,   "size": "512M",   "ro": false,   "type": "part"}
-    {
-        "name": "sda2",         "maj:min": "8:2",         "rm": false,
-        "size": "476.4G",         "ro": false,         "type": "part"
-    }
-    {
-        "name": "",         "maj:min": "254:0",
-        "rm": false,         "size": "476.4G",         "ro": false,         "type": "crypt"      }
-    {
-        "name": "-swap",
-        "maj:min": "254:1",
-        "rm": false,
-        "size": "8G",
-        "ro": false,
-        "type": "lvm"
-    }
-    {"name":
-
-
-
-
-    "-root","maj:min":"254:2","rm":false,"size":"32G","ro":false,"type":"lvm"}
-
-
-
-    {         "name": "-home",
-        "maj:min": "254:3",
-        "rm": false,         "size": "436.4G",
-        "ro": false,
-        "type": "lvm"      }
-
-"""
-
-equ = [
-    {'name': 'sda', 'maj:min': '8:0', 'rm': False, 'size': '476.9G', 'ro': False, 'type': 'disk'},
-    {'name': 'sda1', 'maj:min': '8:1', 'rm': False, 'size': '512M', 'ro': False, 'type': 'part'},
-    {'name': 'sda2', 'maj:min': '8:2', 'rm': False, 'size': '476.4G', 'ro': False, 'type': 'part'},
-    {'name': '', 'maj:min': '254:0', 'rm': False, 'size': '476.4G', 'ro': False, 'type': 'crypt'},
-    {'name': '-swap', 'maj:min': '254:1', 'rm': False, 'size': '8G', 'ro': False, 'type': 'lvm'},
-    {'name': '-root', 'maj:min': '254:2', 'rm': False, 'size': '32G', 'ro': False, 'type': 'lvm'},
-    {'name': '-home', 'maj:min': '254:3', 'rm': False, 'size': '436.4G', 'ro': False, 'type': 'lvm'},
-]
-
-
-@tester.add()
-def toJsonLoad():
-    a = io.BytesIO(data.encode())
-    Assert([x for x in JqLoad().fromFile(a)]).eq(equ)
-
-    a = io.BytesIO(data.encode())
-    Assert([x for x in JqLoad().fromFile(a, amnt=2)]).eq(equ)
-
-
-@tester.add()
-def toJsonSave():
-    tmp = Dath.Temp().tempFile(autoRemove=T)
-
-    with defl.JqDump(output=tmp) as d:
-        for i in equ:
-            d.dump(i)
-    t = tmp.read_text().split('\n')
-    Assert(t) == [
-        '{"name":"sda","maj:min":"8:0","rm":false,"size":"476.9G","ro":false,"type":"disk"}',
-        '{"name":"sda1","maj:min":"8:1","rm":false,"size":"512M","ro":false,"type":"part"}',
-        '{"name":"sda2","maj:min":"8:2","rm":false,"size":"476.4G","ro":false,"type":"part"}',
-        '{"name":"","maj:min":"254:0","rm":false,"size":"476.4G","ro":false,"type":"crypt"}',
-        '{"name":"-swap","maj:min":"254:1","rm":false,"size":"8G","ro":false,"type":"lvm"}',
-        '{"name":"-root","maj:min":"254:2","rm":false,"size":"32G","ro":false,"type":"lvm"}',
-        '{"name":"-home","maj:min":"254:3","rm":false,"size":"436.4G","ro":false,"type":"lvm"}',
-        '',
-    ]
-
-
-@tester.add()
-def pydant():
-    @dantClass()
-    class A:
-        a: int
-        b: list['A'] | N = N
-
-    a = A(a=1, b=(A(a=2), A(a=3)))
-    for i in [
-        '__pydantic_complete__',
-        '__pydantic_config__',
-        '__pydantic_core_schema__',
-        '__pydantic_decorators__',
-        '__pydantic_fields__',
-        '__pydantic_serializer__',
-        '__pydantic_validator__',
-    ]:
-        print(i, getattr(a, i))
-    a = defl.jsonReprDump(a)
-    Assert(a) == {'a': 1, 'b': [{'a': 2, 'b': None}, {'a': 3, 'b': None}]}
-
-
-log.info(tester.run())
-tester.exitWithStatus()
+def test_jqDump2():
+    tmpPath = defl.sp.tmp.makeTemp([], autoRemove=T, create=T, direct=F, ext=N)
+    with defl.JqDump(tmpPath, append=T) as jq:
+        jq.dump({'a': 'a'})
+        sleep(0.2)  # | flushing to file is async
+        res = tmpPath.readText()
+        assert res == '{"a":"a"}\n'
diff --git a/todo.md b/todo.md
new file mode 100644
index 0000000..bc721c6
--- /dev/null
+++ b/todo.md
@@ -0,0 +1,21 @@
+```
+pip install
+pytest
+https://github.com/ArjanCodes/2022-test-existing-code/blob/main/after/pay/tests/test_payment.py
+dependency injection
+pytest.mark.parameterize
+mocker.patch('main.requests.get')
+assert_called_once_with
+```
+
+use `protocal` to mock data
+pytset.fixture
+https://typing.python.org/en/latest/spec/protocol.html#protocols
+
+```
+from pytest import MonkeyPatch
+def test_pay_order(monkeypatch: MonkeyPatch):
+    inputs = ["1249190007575069", "12", "2024"]
+    monkeypatch.setattr("builtins.input", lambda _: inputs.pop(0))
+    monkeypatch.setattr(PaymentProcessor, "_check_api_key", lambda _: True)
+```