ominfra 0.0.0.dev438__py3-none-any.whl → 0.0.0.dev483__py3-none-any.whl

ominfra/scripts/manage.py

@@ -34,6 +34,7 @@ import io
 import itertools
 import json
 import logging
+import operator
 import os
 import os.path
 import platform
@@ -65,6 +66,142 @@ if sys.version_info < (3, 8):
     raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
 
 
+def __omlish_amalg__():  # noqa
+    return dict(
+        src_files=[
+            dict(path='../../omdev/packaging/versions.py', sha1='71627ad600b3529b829b0e227b0952f2c63c7271'),
+            dict(path='config.py', sha1='6ff640634488fa142d9aadee5aec95db462ce46f'),
+            dict(path='deploy/config.py', sha1='b11f480014b42206531ea897e76dd0220eb59969'),
+            dict(path='deploy/paths/types.py', sha1='4364179744afb2344f2b44d188e37f786c955970'),
+            dict(path='deploy/types.py', sha1='41b2becf7a9d009e18235a8b49cfbe0419785190'),
+            dict(path='../pyremote.py', sha1='2131faabec13af3d29747d9430286394603445ca'),
+            dict(path='../../omlish/asyncs/asyncio/channels.py', sha1='36cec6ea48887baaf536ae6301ec6ebc70f9f19b'),
+            dict(path='../../omlish/asyncs/asyncio/streams.py', sha1='78a498b78b51805d3b44ba7fe8c10c575389c6a9'),
+            dict(path='../../omlish/configs/types.py', sha1='f7a5584cd6eccb77d18d729796072a162e9a8790'),
+            dict(path='../../omlish/formats/ini/sections.py', sha1='731c92cce82e183d1d4bdc23fc781fad62187394'),
+            dict(path='../../omlish/formats/toml/parser.py', sha1='73dac82289350ab951c4bcdbfe61167fa221f26f'),
+            dict(path='../../omlish/formats/toml/writer.py', sha1='6ea41d7e724bb1dcf6bd84b88993ff4e8798e021'),
+            dict(path='../../omlish/lite/abstract.py', sha1='a2fc3f3697fa8de5247761e9d554e70176f37aac'),
+            dict(path='../../omlish/lite/attrops.py', sha1='c1ebfb8573d766d34593c452a2377208d02726dc'),
+            dict(path='../../omlish/lite/cached.py', sha1='0c33cf961ac8f0727284303c7a30c5ea98f714f2'),
+            dict(path='../../omlish/lite/check.py', sha1='bb6b6b63333699b84462951a854d99ae83195b94'),
+            dict(path='../../omlish/lite/contextmanagers.py', sha1='993f5ed96d3410f739a20363f55670d5e5267fa3'),
+            dict(path='../../omlish/lite/json.py', sha1='57eeddc4d23a17931e00284ffa5cb6e3ce089486'),
+            dict(path='../../omlish/lite/objects.py', sha1='9566bbf3530fd71fcc56321485216b592fae21e9'),
+            dict(path='../../omlish/lite/pycharm.py', sha1='6f84e57f02e2f1075918002f89e4201910d2a15e'),
+            dict(path='../../omlish/lite/reflect.py', sha1='c4fec44bf144e9d93293c996af06f6c65fc5e63d'),
+            dict(path='../../omlish/lite/resources.py', sha1='1365cb6046eb929358e7c86a3fda20d95fd4a296'),
+            dict(path='../../omlish/lite/strings.py', sha1='89831ecbc34ad80e118a865eceb390ed399dc4d6'),
+            dict(path='../../omlish/lite/typing.py', sha1='deaaa560b63d9a0e40991ec0006451f5f0df04c1'),
+            dict(path='../../omlish/logs/levels.py', sha1='91405563d082a5eba874da82aac89d83ce7b6152'),
+            dict(path='../../omlish/logs/std/filters.py', sha1='f36aab646d84d31e295b33aaaaa6f8b67ff38b3d'),
+            dict(path='../../omlish/logs/std/proxy.py', sha1='3e7301a2aa351127f9c85f61b2f85dcc3f15aafb'),
+            dict(path='../../omlish/logs/warnings.py', sha1='c4eb694b24773351107fcc058f3620f1dbfb6799'),
+            dict(path='../../omlish/os/deathsig.py', sha1='5d3f1a22132b7029d32e29b13c1cc20497c8f7a8'),
+            dict(path='../../omlish/os/environ.py', sha1='5e9ed4817af65683b496af49fef996630c3113b1'),
+            dict(path='../../omlish/os/linux.py', sha1='b6433d321eba7afab353b04107819fdc72f1d836'),
+            dict(path='../../omlish/os/paths.py', sha1='56c40b7c2aa84d1778d60ee4cda498f8c380cc8d'),
+            dict(path='../../omlish/shlex.py', sha1='a69721913bcd4f4008600e390fb7822637c2a8ec'),
+            dict(path='../../omdev/home/paths.py', sha1='a83516c97a2e99e79153a414db3d23091186bb23'),
+            dict(path='../../omdev/packaging/specifiers.py', sha1='a56ab4e8c9b174adb523921f6280ac41e0fce749'),
+            dict(path='deploy/paths/specs.py', sha1='023167da1ad9fcf09d9d44963177175591a97377'),
+            dict(path='remote/config.py', sha1='48f9367e9db4b23166657ff34eb644c9869d48a8'),
+            dict(path='remote/payload.py', sha1='acacf4c2901b7708224af5d4414ecb823947297a'),
+            dict(path='targets/bestpython.py', sha1='75c16ab86397a8e81017f148a2ef711567b6ab27'),
+            dict(path='targets/targets.py', sha1='d07f2d30c31bad89bd4a3b44bb6a5b6c95c05888'),
+            dict(path='../../omlish/argparse/cli.py', sha1='f4dc3cd353d14386b5da0306768700e396afd2b3'),
+            dict(path='../../omlish/configs/formats.py', sha1='9bc4f953b4b8700f6f109e6f49e2d70f8e48ce7c'),
+            dict(path='../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
+            dict(path='../../omlish/lite/maybes.py', sha1='bdf5136654ccd14b6a072588cad228925bdfbabd'),
+            dict(path='../../omlish/lite/runtime.py', sha1='2e752a27ae2bf89b1bb79b4a2da522a3ec360c70'),
+            dict(path='../../omlish/lite/timeouts.py', sha1='a0f673033a6943f242e35848d78a41892b9c62a1'),
+            dict(path='../../omlish/logs/infos.py', sha1='4dd104bd468a8c438601dd0bbda619b47d2f1620'),
+            dict(path='../../omlish/logs/protocols.py', sha1='05ca4d1d7feb50c4e3b9f22ee371aa7bf4b3dbd1'),
+            dict(path='../../omlish/logs/std/json.py', sha1='2a75553131e4d5331bb0cedde42aa183f403fc3b'),
+            dict(path='../../omlish/os/atomics.py', sha1='ccb62620b95f60ac50561c283d50e5fcfdccb215'),
+            dict(path='../../omlish/text/indent.py', sha1='cc23647bdcd8d26c8afe9e36a0aefb32da58cbb8'),
+            dict(path='../../omdev/interp/types.py', sha1='cfc14929777fb19f723c875bcafc8f7c66593d6d'),
+            dict(path='commands/base.py', sha1='17310f7272b6ac7b6438e32bfd7b24004d284399'),
+            dict(path='deploy/conf/specs.py', sha1='d191fa887c59198f5eff5c62414031204a76fa65'),
+            dict(path='deploy/tags.py', sha1='e6e7a1f4fcee9f5764acbe7f307b31e26f81bbc3'),
+            dict(path='marshal.py', sha1='175f59215a92afd42468f6258f1202b9ec3362cb'),
+            dict(path='remote/channel.py', sha1='2b6498da48ff89901b88a6a1ef84c58b37ddb410'),
+            dict(path='../../omlish/asyncs/asyncio/timeouts.py', sha1='4d31b02b3c39b8f2fa7e94db36552fde6942e36a'),
+            dict(path='../../omlish/configs/nginx.py', sha1='d0ad33c21674fc02f23281247517c827f455eb0b'),
+            dict(path='../../omlish/lite/configs.py', sha1='c8602e0e197ef1133e7e8e248935ac745bfd46cb'),
+            dict(path='../../omlish/lite/inject.py', sha1='6f097e3170019a34ff6834d36fcc9cbeed3a7ab4'),
+            dict(path='../../omlish/logs/contexts.py', sha1='7456964ade9ac66460e9ade4e242dbdc24b39501'),
+            dict(path='../../omlish/logs/standard.py', sha1='818b674f7d15012f25b79f52f6e8e7368b633038'),
+            dict(path='../../omlish/subprocesses/run.py', sha1='8200e48f0c49d164df3503cd0143038d0c4d30aa'),
+            dict(path='../../omlish/subprocesses/wrap.py', sha1='8a9b7d2255481fae15c05f5624b0cdc0766f4b3f'),
+            dict(path='../../omdev/interp/providers/base.py', sha1='f5d068c21f230d742e9015b033cd6320f4c68898'),
+            dict(path='commands/injection.py', sha1='f7d8aec3c33efc61da1f0c6700bdfbe7bcc10e56'),
+            dict(path='commands/marshal.py', sha1='a21c3a75fe17bb80d32d10a3d5524d67a96ea210'),
+            dict(path='commands/ping.py', sha1='af4c34e9b1811269c954cf502b336a6446639a2a'),
+            dict(path='commands/types.py', sha1='10b88571981b9964287f30f27abf6d09400b51c6'),
+            dict(path='deploy/paths/paths.py', sha1='bf7794e998caa1611277ac5809eb7ec91a76d1e8'),
+            dict(path='deploy/specs.py', sha1='b3a411b32b47f81f5ad673d8b0338970a6eb6ff9'),
+            dict(path='../../omlish/logs/base.py', sha1='a376460b11b9dc0555fd4ead5437af62c2109a4b'),
+            dict(path='../../omlish/logs/std/records.py', sha1='8bbf6ef9eccb3a012c6ca416ddf3969450fd8fc9'),
+            dict(path='../../omlish/subprocesses/base.py', sha1='cb9f668be5422fecb27222caabb67daac6c1bab9'),
+            dict(path='../../omdev/interp/resolvers.py', sha1='817b8e76401cd7a19eb43ca54d65272e4c8a4b0e'),
+            dict(path='commands/local.py', sha1='db3c5b0a1f067f54e2133234e36e7db393e4dec3'),
+            dict(path='deploy/conf/manager.py', sha1='7450a8616dbc46f6c68387192035a6ea258aebe2'),
+            dict(path='deploy/paths/owners.py', sha1='382bcec4824f0fc71dddf083c6e88748b5c62ef2'),
+            dict(path='../../omlish/logs/std/loggers.py', sha1='daa35bdc4adea5006e442688017f0de3392579b7'),
+            dict(path='../../omlish/subprocesses/asyncs.py', sha1='bba44d524c24c6ac73168aee6343488414e5bf48'),
+            dict(path='../../omlish/subprocesses/sync.py', sha1='8434919eba4da67825773d56918fdc0cb2f1883b'),
+            dict(path='../../omdev/git/shallow.py', sha1='7b5f9d77b7a01df5828ca61a2adc6dae54cf676b'),
+            dict(path='deploy/injection.py', sha1='7d641dd20ff0c75de5679079c52647653849d6cc'),
+            dict(path='deploy/paths/manager.py', sha1='eb1c84e0ca03083f69b53cee25bf7ffd752cc7a9'),
+            dict(path='deploy/tmp.py', sha1='d8b7aeaa26ab58e64aba371d46bc661462d47c5e'),
+            dict(path='../../omlish/asyncs/asyncio/subprocesses.py', sha1='b6b5f9ae3fd0b9c83593bad2e04a08f726e5904d'),
+            dict(path='../../omlish/logs/modules.py', sha1='99e73cde6872fd5eda6af3dbf0fc9322bdeb641a'),
+            dict(path='../../omdev/interp/inspect.py', sha1='736287b4ec8d14a8c30afa0ba23996fdc0662caa'),
+            dict(path='../../omdev/interp/pyenv/pyenv.py', sha1='d1f6e657c671c1b1a5b0e627284df656fe2d10d3'),
+            dict(path='../../omdev/interp/uv/uv.py', sha1='8c6515cd6755efab3972da92a285e94ccb255515'),
+            dict(path='commands/subprocess.py', sha1='788bd859701fce066bd00c820919f826b43b8b57'),
+            dict(path='deploy/conf/inject.py', sha1='d006b45d92f3b5f30a797b65fbed23f90c3db490'),
+            dict(path='deploy/git.py', sha1='5ee2e816e18fef493cb2ccc33f33ad673175ad7a'),
+            dict(path='deploy/paths/inject.py', sha1='1c501d086fcbde9c2b9ead21fc3c7b175bbf4f76'),
+            dict(path='deploy/systemd.py', sha1='773c4482e85a974443bb26237a86b1dfbcd9936c'),
+            dict(path='remote/execution.py', sha1='005da809e58790a0e5255df8e57afd5cd6268d7d'),
+            dict(path='remote/spawning.py', sha1='9cb6b5da1ba6daabb35a5742be647748c01d40d3'),
+            dict(path='system/packages.py', sha1='9988fc93dbca9336c378bf5fad6f68f5b8c0260e'),
+            dict(path='system/platforms.py', sha1='f3fc312318cff15f97dd9b10fa5f2408abc45a1b'),
+            dict(path='../../omdev/interp/providers/running.py', sha1='85c9cc69ff6fbd6c8cf78ed6262619a30856c2f1'),
+            dict(path='../../omdev/interp/providers/system.py', sha1='9638a154475ca98775159d27739563ac7fb2eb16'),
+            dict(path='../../omdev/interp/pyenv/install.py', sha1='4a10a19717364b4ba9f3b8bf1d12621cf21ba8b8'),
+            dict(path='../../omdev/interp/uv/provider.py', sha1='149f19f95eb701ffad5dc74392f4692c21b5f8c0'),
+            dict(path='commands/inject.py', sha1='7a95b6487b01230dd2fe0d9f67382d8889039e7b'),
+            dict(path='system/commands.py', sha1='17bbaa945b6ded0a88d31c52b410cbce8fc324a0'),
+            dict(path='system/config.py', sha1='fd1ebc2cf36fd312ff69d1af100a7e9c638f1fcc'),
+            dict(path='../../omdev/interp/providers/inject.py', sha1='7cc9ebf58cf2ec09545321456bd9da9f9a3a79fb'),
+            dict(path='../../omdev/interp/pyenv/provider.py', sha1='377542ce01a35849e2a5b4a4dbafedc26882f983'),
+            dict(path='../../omdev/interp/uv/inject.py', sha1='e95d058c2340baa5a3155ec3440f311d1daa10a8'),
+            dict(path='bootstrap.py', sha1='e66138947a41e8a49576885cf4b1390315d44f88'),
+            dict(path='system/inject.py', sha1='8a34be1b982cb42981c08306f12994a0fff258bd'),
+            dict(path='../../omdev/interp/pyenv/inject.py', sha1='b8fb68f5a7cae86c70fe1bad6c29a8b2dfc985c3'),
+            dict(path='remote/_main.py', sha1='5ae1dc673ce22f2d40612c66b3a5c3d01ebb6718'),
+            dict(path='../../omdev/interp/inject.py', sha1='b039abbadf0b096d2724182af2e0ebda2a230852'),
+            dict(path='remote/connection.py', sha1='18bc6c4a446a9bef3c54b861a01418b1b7ba39ff'),
+            dict(path='../../omdev/interp/default.py', sha1='a799969a0d3f4b57538587b13ceb08f6334ebc16'),
+            dict(path='remote/inject.py', sha1='8713a421b18ff7625c95017616380f0500c3c39c'),
+            dict(path='targets/connection.py', sha1='891f1d35ee3814bed32e6de71e1ca47574635da1'),
+            dict(path='deploy/interp.py', sha1='89371a87a275fea2e8566a0983e4906cda46a105'),
+            dict(path='deploy/venvs.py', sha1='7ad41a11098dd68d83a0804d2ea95779d0be4de0'),
+            dict(path='targets/inject.py', sha1='e4bfba31b044da9545d4c00965e7e15b97a40cce'),
+            dict(path='deploy/apps.py', sha1='6df5d728b6715583a792d1e92268c0c07502509f'),
+            dict(path='deploy/deploy.py', sha1='635f84ad370b22797406d2ae55d78621ea1f7b2b'),
+            dict(path='deploy/commands.py', sha1='0e9fdd122fe3a4028efede0862b059c091cc13cb'),
+            dict(path='deploy/inject.py', sha1='d84e9c3e980c5a1ec62d18628d8911f5b6bb125f'),
+            dict(path='inject.py', sha1='b1c173df021f190d3631f3828470fa1564e0b4b4'),
+            dict(path='bootstrap_.py', sha1='c7d7c3e88703200a836df63e395f7154bf871f36'),
+            dict(path='main.py', sha1='ddddcdb54aabe67188dce6a5f65e04ce296a75b0'),
+        ],
+    )
+
+
 ########################################
 
 
@@ -90,7 +227,7 @@ TomlParseFloat = ta.Callable[[str], ta.Any]  # ta.TypeAlias
 TomlKey = ta.Tuple[str, ...]  # ta.TypeAlias
 TomlPos = int  # ta.TypeAlias
 
-# ../../omlish/lite/attrops.py
+# ../../omlish/lite/abstract.py
 T = ta.TypeVar('T')
 
 # ../../omlish/lite/cached.py
@@ -281,12 +418,12 @@ class _BaseVersion:
 
     def __lt__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key < other._key
 
     def __le__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key <= other._key
 
     def __eq__(self, other: object) -> bool:
@@ -296,12 +433,12 @@ class _BaseVersion:
 
     def __ge__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key >= other._key
 
     def __gt__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key > other._key
 
     def __ne__(self, other: object) -> bool:
@@ -2394,25 +2531,49 @@ def is_abstract_method(obj: ta.Any) -> bool:
     return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
-def update_abstracts(cls, *, force=False):
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
     if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
         # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
         # implementation (especially during testing), and we want to handle both cases.
         return cls
 
-    abstracts: ta.Set[str] = set()
-
-    for scls in cls.__bases__:
-        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
-            value = getattr(cls, name, None)
-            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-                abstracts.add(name)
-
-    for name, value in cls.__dict__.items():
-        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-            abstracts.add(name)
-
-    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
     return cls
 
 
@@ -2466,23 +2627,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
-
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 
@@ -2507,6 +2671,8 @@ TODO:
  - per-attr repr transform / filter
  - __ne__ ? cases where it still matters
  - ordering ?
+ - repr_filter: ta.Union[ta.Callable[[ta.Any], ta.Optional[str]], ta.Literal['not_none', 'truthy']]] ?
+  - unify repr/repr_fn/repr_filter
 """
 
 
@@ -2524,6 +2690,8 @@ class AttrOps(ta.Generic[T]):
                 display: ta.Optional[str] = None,
 
                 repr: bool = True,  # noqa
+                repr_fn: ta.Optional[ta.Callable[[ta.Any], ta.Optional[str]]] = None,
+
                 hash: bool = True,  # noqa
                 eq: bool = True,
         ) -> None:
@@ -2538,6 +2706,8 @@ class AttrOps(ta.Generic[T]):
             self._display = display
 
             self._repr = repr
+            self._repr_fn = repr_fn
+
             self._hash = hash
             self._eq = eq
 
@@ -2545,21 +2715,30 @@ class AttrOps(ta.Generic[T]):
         def of(
                 cls,
                 o: ta.Union[
-                    str,
-                    ta.Tuple[str, str],
                     'AttrOps.Attr',
+                    str,
+                    ta.Tuple[str, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                    ta.Mapping[str, ta.Any],
                 ],
         ) -> 'AttrOps.Attr':
             if isinstance(o, AttrOps.Attr):
                 return o
             elif isinstance(o, str):
                 return cls(o)
+            elif isinstance(o, tuple):
+                name, x = o
+                kw: ta.Mapping[str, ta.Any]
+                if isinstance(x, str):
+                    kw = dict(display=x)
+                elif isinstance(x, ta.Mapping):
+                    kw = x
+                else:
+                    raise TypeError(x)
+                return cls(name, **kw)
+            elif isinstance(o, ta.Mapping):
+                return cls(**o)
             else:
-                name, disp = o
-                return cls(
-                    name,
-                    display=disp,
-                )
+                raise TypeError(o)
 
         @property
         def name(self) -> str:
@@ -2577,19 +2756,34 @@ class AttrOps(ta.Generic[T]):
         def eq(self) -> bool:
             return self._eq
 
+    @staticmethod
+    def opt_repr(o: ta.Any) -> ta.Optional[str]:
+        return repr(o) if o is not None else None
+
+    @staticmethod
+    def truthy_repr(o: ta.Any) -> ta.Optional[str]:
+        return repr(o) if o else None
+
+    #
+
     @ta.overload
     def __init__(
             self,
             *attrs: ta.Sequence[ta.Union[
                 str,
-                ta.Tuple[str, str],
+                ta.Tuple[str, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                ta.Mapping[str, ta.Any],
                 Attr,
             ]],
+
             with_module: bool = False,
             use_qualname: bool = False,
             with_id: bool = False,
+            terse: bool = False,
             repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
             recursive: bool = False,
+
+            cache_hash: ta.Union[bool, str] = False,
             subtypes_eq: bool = False,
     ) -> None:
         ...
@@ -2599,16 +2793,20 @@ class AttrOps(ta.Generic[T]):
             self,
             attrs_fn: ta.Callable[[T], ta.Tuple[ta.Union[
                 ta.Any,
-                ta.Tuple[str, ta.Any],
+                ta.Tuple[ta.Any, ta.Union[str, ta.Mapping[str, ta.Any]]],
                 Attr,
             ], ...]],
             /,
             *,
+
             with_module: bool = False,
             use_qualname: bool = False,
             with_id: bool = False,
+            terse: bool = False,
             repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
             recursive: bool = False,
+
+            cache_hash: ta.Union[bool, str] = False,
             subtypes_eq: bool = False,
     ) -> None:
         ...
@@ -2616,11 +2814,15 @@ class AttrOps(ta.Generic[T]):
     def __init__(
             self,
             *args,
+
             with_module=False,
             use_qualname=False,
             with_id=False,
+            terse=False,
             repr_filter=None,
             recursive=False,
+
+            cache_hash=False,
             subtypes_eq=False,
     ) -> None:
         if args and len(args) == 1 and callable(args[0]):
@@ -2631,8 +2833,11 @@ class AttrOps(ta.Generic[T]):
         self._with_module: bool = with_module
         self._use_qualname: bool = use_qualname
         self._with_id: bool = with_id
+        self._terse: bool = terse
         self._repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = repr_filter
         self._recursive: bool = recursive
+
+        self._cache_hash: ta.Union[bool, str] = cache_hash
         self._subtypes_eq: bool = subtypes_eq
 
     @property
@@ -2667,20 +2872,27 @@ class AttrOps(ta.Generic[T]):
 
         attrs: ta.List[AttrOps.Attr] = []
         for o in raw:
-            if isinstance(o, AttrOps.Attr):
-                attrs.append(o)
+            if isinstance(o, (AttrOps.Attr, ta.Mapping)):
+                attrs.append(AttrOps.Attr.of(o))
                 continue
 
+            kw: ta.Mapping[str, ta.Any]
             if isinstance(o, tuple):
-                disp, cap, = o
+                cap, x = o
+                if isinstance(x, str):
+                    kw = dict(display=x)
+                elif isinstance(x, ta.Mapping):
+                    kw = x
+                else:
+                    raise TypeError(x)
             else:
-                disp, cap = None, o
+                cap, kw = o, {}
 
             path = tuple(rec(cap))
 
             attrs.append(AttrOps.Attr(
                 '.'.join(path),
-                display=disp,
+                **kw,
             ))
 
         return attrs
@@ -2697,19 +2909,27 @@ class AttrOps(ta.Generic[T]):
             pass
 
         def _repr(o: T) -> str:
-            vs = ', '.join(
-                f'{a._display}={v!r}'  # noqa
-                for a in self._attrs
-                if a._repr  # noqa
-                for v in [getattr(o, a._name)]  # noqa
-                if self._repr_filter is None or self._repr_filter(v)
-            )
+            vs: ta.List[str] = []
+            for a in self._attrs:
+                if not a._repr:  # noqa
+                    continue
+                v = getattr(o, a._name)  # noqa
+                if self._repr_filter is not None and not self._repr_filter(v):
+                    continue
+                if (rfn := a._repr_fn) is None:  # noqa
+                    rfn = repr
+                if (vr := rfn(v)) is None:
+                    continue
+                if self._terse:
+                    vs.append(vr)
+                else:
+                    vs.append(f'{a._display}={vr}')  # noqa
 
             return (
                 f'{o.__class__.__module__ + "." if self._with_module else ""}'
                 f'{o.__class__.__qualname__ if self._use_qualname else o.__class__.__name__}'
                 f'{("@" + hex(id(o))[2:]) if self._with_id else ""}'  # noqa
-                f'({vs})'
+                f'({", ".join(vs)})'
             )
 
         if self._recursive:
@@ -2734,6 +2954,8 @@ class AttrOps(ta.Generic[T]):
 
     #
 
+    _DEFAULT_CACHED_HASH_ATTR: ta.ClassVar[str] = '__cached_hash__'
+
     _hash: ta.Callable[[T], int]
 
     @property
@@ -2743,13 +2965,33 @@ class AttrOps(ta.Generic[T]):
         except AttributeError:
             pass
 
-        def _hash(o: T) -> int:
+        def _calc_hash(o: T) -> int:
             return hash(tuple(
                 getattr(o, a._name)  # noqa
                 for a in self._attrs
                 if a._hash  # noqa
             ))
 
+        if (ch := self._cache_hash) is not False:
+            if ch is True:
+                cha = self._DEFAULT_CACHED_HASH_ATTR
+            elif isinstance(ch, str):
+                cha = ch
+            else:
+                raise TypeError(ch)
+
+            def _cached_hash(o: T) -> int:
+                try:
+                    return object.__getattribute__(o, cha)
+                except AttributeError:
+                    object.__setattr__(o, cha, h := _calc_hash(o))
+                return h
+
+            _hash = _cached_hash
+
+        else:
+            _hash = _calc_hash
+
         self._hash = _hash
         return _hash
 
@@ -2890,6 +3132,62 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
     return _AsyncCachedNullary(fn)
 
 
+##
+
+
+cached_property = functools.cached_property
+
+
+class _cached_property:  # noqa
+    """Backported to pick up https://github.com/python/cpython/commit/056dfc71dce15f81887f0bd6da09d6099d71f979 ."""
+
+    def __init__(self, func):
+        self.func = func
+        self.attrname = None  # noqa
+        self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
+
+    _NOT_FOUND = object()
+
+    def __set_name__(self, owner, name):
+        if self.attrname is None:
+            self.attrname = name  # noqa
+        elif name != self.attrname:
+            raise TypeError(
+                f'Cannot assign the same cached_property to two different names ({self.attrname!r} and {name!r}).',
+            )
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.attrname is None:
+            raise TypeError('Cannot use cached_property instance without calling __set_name__ on it.')
+
+        try:
+            cache = instance.__dict__
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            raise TypeError(
+                f"No '__dict__' attribute on {type(instance).__name__!r} instance to cache {self.attrname!r} property.",
+            ) from None
+
+        val = cache.get(self.attrname, self._NOT_FOUND)
+
+        if val is self._NOT_FOUND:
+            val = self.func(instance)
+            try:
+                cache[self.attrname] = val
+            except TypeError:
+                raise TypeError(
+                    f"The '__dict__' attribute on {type(instance).__name__!r} instance does not support item "
+                    f"assignment for caching {self.attrname!r} property.",
+                ) from None
+
+        return val
+
+
+globals()['cached_property'] = _cached_property
+
+
 ########################################
 # ../../../omlish/lite/check.py
 """
@@ -3429,7 +3727,7 @@ class ExitStacked:
             es.__enter__()
             try:
                 self._enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 es.__exit__(*sys.exc_info())
                 raise
             return self
@@ -3440,7 +3738,7 @@ class ExitStacked:
             return None
         try:
             self._exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             es.__exit__(*sys.exc_info())
             raise
         return es.__exit__(exc_type, exc_val, exc_tb)
@@ -3488,7 +3786,7 @@ class AsyncExitStacked:
             await es.__aenter__()
             try:
                 await self._async_enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 await es.__aexit__(*sys.exc_info())
                 raise
             return self
@@ -3499,7 +3797,7 @@ class AsyncExitStacked:
             return None
         try:
             await self._async_exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             await es.__aexit__(*sys.exc_info())
             raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)
@@ -3697,7 +3995,7 @@ def dir_dict(o: ta.Any) -> ta.Dict[str, ta.Any]:
 ##
 
 
-DEFAULT_PYCHARM_VERSION = '242.23726.102'
+DEFAULT_PYCHARM_VERSION = '252.26199.168'
 
 
 @dc.dataclass(frozen=True)
@@ -3941,6 +4239,12 @@ def format_num_bytes(num_bytes: int) -> str:
 
 ##
 # A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+#
+# Note that this problem doesn't happen at runtime - it happens in mypy:
+#
+#   mypy <(echo "import typing as ta; MyCallback = ta.NewType('MyCallback', ta.Callable[[], None])")
+#   /dev/fd/11:1:22: error: Argument 2 to NewType(...) must be subclassable (got "Callable[[], None]")  [valid-newtype]
+#
 
 
 @dc.dataclass(frozen=True)
@@ -5483,7 +5787,7 @@ class SpecifierSet(BaseSpecifier):
         if isinstance(other, str):
             other = SpecifierSet(other)
         elif not isinstance(other, SpecifierSet):
-            return NotImplemented  # type: ignore
+            return NotImplemented
 
         specifier = SpecifierSet()
         specifier._specs = frozenset(self._specs | other._specs)
@@ -5503,6 +5807,7 @@ class SpecifierSet(BaseSpecifier):
         if isinstance(other, (str, Specifier)):
             other = SpecifierSet(str(other))
         elif not isinstance(other, SpecifierSet):
+
             return NotImplemented
 
         return self._specs == other._specs
@@ -5789,6 +6094,7 @@ TODO:
  - pre-run, post-run hooks
  - exitstack?
  - suggestion - difflib.get_close_matches
+ - add_argument_group - group kw on ArgparseKwarg?
 """
 
 
@@ -5799,6 +6105,7 @@ TODO:
 class ArgparseArg:
     args: ta.Sequence[ta.Any]
     kwargs: ta.Mapping[str, ta.Any]
+    group: ta.Optional[str] = None
     dest: ta.Optional[str] = None
 
     def __get__(self, instance, owner=None):
@@ -5808,7 +6115,11 @@ class ArgparseArg:
 
 
 def argparse_arg(*args, **kwargs) -> ArgparseArg:
-    return ArgparseArg(args, kwargs)
+    return ArgparseArg(
+        args=args,
+        group=kwargs.pop('group', None),
+        kwargs=kwargs,
+    )
 
 
 def argparse_arg_(*args, **kwargs) -> ta.Any:
@@ -5978,6 +6289,10 @@ class ArgparseCli:
                     subparser.set_defaults(_cmd=obj)
 
             elif isinstance(obj, ArgparseArg):
+                if obj.group is not None:
+                    # FIXME: add_argument_group
+                    raise NotImplementedError
+
                 if att in anns:
                     ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
                     obj.kwargs = {**ann_kwargs, **obj.kwargs}
@@ -6023,7 +6338,7 @@ class ArgparseCli:
 
         if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
             msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
-            if (parser := self.get_parser()).exit_on_error:
+            if (parser := self.get_parser()).exit_on_error:  # noqa
                 parser.error(msg)
             else:
                 raise argparse.ArgumentError(None, msg)
@@ -6043,7 +6358,10 @@ class ArgparseCli:
         return fn()
 
     def cli_run_and_exit(self) -> ta.NoReturn:
-        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+        rc = self.cli_run()
+        if not isinstance(rc, int):
+            rc = 0
+        raise SystemExit(rc)
 
     def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
         if exit:
@@ -7228,8 +7546,6 @@ class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property
@@ -7287,6 +7603,13 @@ class _EmptyMaybe(_Maybe[T]):
 Maybe._empty = _EmptyMaybe()  # noqa
 
 
+##
+
+
+setattr(Maybe, 'just', _JustMaybe)  # noqa
+setattr(Maybe, 'empty', functools.partial(operator.attrgetter('_empty'), Maybe))
+
+
 ########################################
 # ../../../omlish/lite/runtime.py
 
@@ -11889,6 +12212,10 @@ class VerboseCalledProcessError(subprocess.CalledProcessError):
 class BaseSubprocesses(Abstract):
     DEFAULT_LOGGER: ta.ClassVar[ta.Optional[LoggerLike]] = None
 
+    PIPE: ta.ClassVar[int] = subprocess.PIPE
+    STDOUT: ta.ClassVar[int] = subprocess.STDOUT
+    DEVNULL: ta.ClassVar[int] = subprocess.DEVNULL
+
     def __init__(
             self,
             *,
@@ -16826,7 +17153,7 @@ class MainCli(ArgparseCli):
 
 
 def _main() -> None:
-    sys.exit(asyncio.run(MainCli().async_cli_run()))
+    raise SystemExit(asyncio.run(MainCli().async_cli_run()))
 
 
 if __name__ == '__main__':