omlish 0.0.0.dev23__py3-none-any.whl → 0.0.0.dev24__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev23'
-__revision__ = '1d019b6879a9552ea31622e40f50d260d6b08824'
+__version__ = '0.0.0.dev24'
+__revision__ = '4ab439ef967fda27804fe7d241924c6f08757b54'
 
 
 #

omlish/bootstrap/diag.py

@@ -166,12 +166,12 @@ class PycharmBootstrap(SimpleBootstrap['PycharmBootstrap.Config']):
     class Config(Bootstrap.Config):
         debug_host: ta.Optional[str] = None
         debug_port: ta.Optional[int] = None
-        debug_version: ta.Optional[str] = None
+        version: ta.Optional[str] = None
 
     def run(self) -> None:
         if self._config.debug_port is not None:
             diagpc.pycharm_remote_debugger_attach(
                 self._config.debug_host,
                 self._config.debug_port,
-                version=self._config.debug_version,
+                version=self._config.version,
             )

omlish/check.py

@@ -75,6 +75,9 @@ def enable_args_rendering() -> bool:
         return True
 
 
+enable_args_rendering()
+
+
 #
 
 
@@ -142,7 +145,14 @@ def _unpack_isinstance_spec(spec: ta.Any) -> tuple:
 
 def isinstance(v: ta.Any, spec: type[T] | tuple, msg: Message = None) -> T:  # noqa
     if not _isinstance(v, _unpack_isinstance_spec(spec)):
-        _raise(TypeError, 'Must be instance', msg, _Args(v, spec))
+        _raise(
+            TypeError,
+            'Must be instance',
+            msg,
+            _Args(v, spec),
+            render_fmt='not isinstance(%s, %s)',
+        )
+
     return v
 
 
@@ -155,7 +165,13 @@ def of_isinstance(spec: type[T] | tuple, msg: Message = None) -> ta.Callable[[ta
 
 def cast(v: ta.Any, cls: type[T], msg: Message = None) -> T:  # noqa
     if not _isinstance(v, cls):
-        _raise(TypeError, 'Must be instance', msg, _Args(v, cls))
+        _raise(
+            TypeError,
+            'Must be instance',
+            msg,
+            _Args(v, cls),
+        )
+
     return v
 
 
@@ -168,7 +184,14 @@ def of_cast(cls: type[T], msg: Message = None) -> ta.Callable[[T], T]:
 
 def not_isinstance(v: T, spec: ta.Any, msg: Message = None) -> T:  # noqa
     if _isinstance(v, _unpack_isinstance_spec(spec)):
-        _raise(TypeError, 'Must not be instance', msg, _Args(v, spec))
+        _raise(
+            TypeError,
+            'Must not be instance',
+            msg,
+            _Args(v, spec),
+            render_fmt='isinstance(%s, %s)',
+        )
+
     return v
 
 
@@ -184,13 +207,27 @@ def of_not_isinstance(spec: ta.Any, msg: Message = None) -> ta.Callable[[T], T]:
 
 def issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
     if not _issubclass(v, spec):
-        _raise(TypeError, 'Must be subclass', msg, _Args(v, spec))
+        _raise(
+            TypeError,
+            'Must be subclass',
+            msg,
+            _Args(v, spec),
+            render_fmt='not issubclass(%s, %s)',
+        )
+
     return v
 
 
 def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
     if _issubclass(v, spec):
-        _raise(TypeError, 'Must not be subclass', msg, _Args(v, spec))
+        _raise(
+            TypeError,
+            'Must not be subclass',
+            msg,
+            _Args(v, spec),
+            render_fmt='issubclass(%s, %s)',
+        )
+
     return v
 
 
@@ -199,19 +236,40 @@ def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  #
 
 def in_(v: T, c: ta.Container[T], msg: Message = None) -> T:
     if v not in c:
-        _raise(ValueError, 'Must be in', msg, _Args(v, c))
+        _raise(
+            ValueError,
+            'Must be in',
+            msg,
+            _Args(v, c),
+            render_fmt='%s not in %s',
+        )
+
     return v
 
 
 def not_in(v: T, c: ta.Container[T], msg: Message = None) -> T:
     if v in c:
-        _raise(ValueError, 'Must not be in', msg, _Args(v, c))
+        _raise(
+            ValueError,
+            'Must not be in',
+            msg,
+            _Args(v, c),
+            render_fmt='%s in %s',
+        )
+
     return v
 
 
 def empty(v: SizedT, msg: Message = None) -> SizedT:
     if len(v) != 0:
-        _raise(ValueError, 'Must be empty', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
@@ -222,20 +280,40 @@ def iterempty(v: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
     except StopIteration:
         pass
     else:
-        _raise(ValueError, 'Must be empty', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
 def not_empty(v: SizedT, msg: Message = None) -> SizedT:
     if len(v) == 0:
-        _raise(ValueError, 'Must not be empty', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must not be empty',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
 def unique(it: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
     dupes = [e for e, c in collections.Counter(it).items() if c > 1]
     if dupes:
-        _raise(ValueError, 'Must be unique', msg, _Args(it, dupes))
+        _raise(
+            ValueError,
+            'Must be unique',
+            msg,
+            _Args(it, dupes),
+        )
+
     return it
 
 
@@ -243,9 +321,15 @@ def single(obj: ta.Iterable[T], message: Message = None) -> T:
     try:
         [value] = obj
     except ValueError:
-        _raise(ValueError, 'Must be single', message, _Args(obj))
-    else:
-        return value
+        _raise(
+            ValueError,
+            'Must be single',
+            message,
+            _Args(obj),
+            render_fmt='%s',
+        )
+
+    return value
 
 
 def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
@@ -254,11 +338,19 @@ def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
         value = next(it)
     except StopIteration:
         return None
+
     try:
         next(it)
     except StopIteration:
         return value  # noqa
-    _raise(ValueError, 'Must be empty or single', message, _Args(obj))
+
+    _raise(
+        ValueError,
+        'Must be empty or single',
+        message,
+        _Args(obj),
+        render_fmt='%s',
+    )
 
 
 ##
@@ -266,12 +358,25 @@ def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
 
 def none(v: ta.Any, msg: Message = None) -> None:
     if v is not None:
-        _raise(ValueError, 'Must be None', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must be None',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
 
 
 def not_none(v: T | None, msg: Message = None) -> T:
     if v is None:
-        _raise(ValueError, 'Must not be None', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must not be None',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
@@ -280,42 +385,115 @@ def not_none(v: T | None, msg: Message = None) -> T:
 
 def equal(v: T, o: ta.Any, msg: Message = None) -> T:
     if o != v:
-        _raise(ValueError, 'Must be equal', msg, _Args(v, o), render_fmt='%s != %s')
+        _raise(
+            ValueError,
+            'Must be equal',
+            msg,
+            _Args(v, o),
+            render_fmt='%s != %s',
+        )
+
     return v
 
 
 def is_(v: T, o: ta.Any, msg: Message = None) -> T:
     if o is not v:
-        _raise(ValueError, 'Must be the same', msg, _Args(v, o), render_fmt='%s is not %s')
+        _raise(
+            ValueError,
+            'Must be the same',
+            msg,
+            _Args(v, o),
+            render_fmt='%s is not %s',
+        )
+
     return v
 
 
 def is_not(v: T, o: ta.Any, msg: Message = None) -> T:
     if o is v:
-        _raise(ValueError, 'Must not be the same', msg, _Args(v, o), render_fmt='%s is %s')
+        _raise(
+            ValueError,
+            'Must not be the same',
+            msg,
+            _Args(v, o),
+            render_fmt='%s is %s',
+        )
+
     return v
 
 
 def callable(v: T, msg: Message = None) -> T:  # noqa
     if not _callable(v):
-        _raise(TypeError, 'Must be callable', msg, _Args(v))
+        _raise(
+            TypeError,
+            'Must be callable',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v  # type: ignore
 
 
 def non_empty_str(v: str | None, msg: Message = None) -> str:
     if not _isinstance(v, str) or not v:
-        _raise(ValueError, 'Must be non-empty str', msg, _Args(v))
+        _raise(
+            ValueError,
+            'Must be non-empty str',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
+
     return v
 
 
+def replacing(expected: ta.Any, old: ta.Any, new: T, msg: Message = None) -> T:
+    if old != expected:
+        _raise(
+            ValueError,
+            'Must be replacing',
+            msg,
+            _Args(expected, old, new),
+            render_fmt='%s -> %s -> %s',
+        )
+
+    return new
+
+
+def replacing_none(old: ta.Any, new: T, msg: Message = None) -> T:
+    if old is not None:
+        _raise(
+            ValueError,
+            'Must be replacing None',
+            msg,
+            _Args(old, new),
+            render_fmt='%s -> %s',
+        )
+
+    return new
+
+
 ##
 
 
 def arg(v: bool, msg: Message = None) -> None:
     if not v:
-        _raise(RuntimeError, 'Argument condition not met', msg)
+        _raise(
+            RuntimeError,
+            'Argument condition not met',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )
 
 
 def state(v: bool, msg: Message = None) -> None:
     if not v:
-        _raise(RuntimeError, 'State condition not met', msg)
+        _raise(
+            RuntimeError,
+            'State condition not met',
+            msg,
+            _Args(v),
+            render_fmt='%s',
+        )

omlish/collections/__init__.py

@@ -95,12 +95,12 @@ from .utils import (  # noqa
     all_not_equal,
     indexes,
     key_cmp,
+    make_map,
+    make_map_by,
     multi_map,
     multi_map_by,
     mut_toposort,
     partition,
     toposort,
     unique,
-    unique_map,
-    unique_map_by,
 )

omlish/collections/utils.py

@@ -72,7 +72,7 @@ def unique(
     return ret
 
 
-def unique_map(
+def make_map(
         kvs: ta.Iterable[tuple[K, V]],
         *,
         identity: bool = False,
@@ -88,14 +88,14 @@ def unique_map(
     return d
 
 
-def unique_map_by(
+def make_map_by(
         fn: ta.Callable[[V], K],
         vs: ta.Iterable[V],
         *,
         identity: bool = False,
         strict: bool = False,
 ) -> ta.MutableMapping[K, V]:
-    return unique_map(
+    return make_map(
         ((fn(v), v) for v in vs),
         identity=identity,
         strict=strict,

omlish/concurrent/threadlets.py

@@ -1,3 +1,8 @@
+"""
+An abstraction over greenlet's api. Greenlet doesn't currently support nogil but its functionality is needed for async
+bridge code (both here and in sqlalchemy). This can be implemented with real threads at the expense of overhead, but
+this code is only intended to be used in already fairly heavy situations (bootstrap, db calls).
+"""
 import abc
 import dataclasses as dc
 import typing as ta

omlish/dataclasses/__init__.py

@@ -94,6 +94,7 @@ from .utils import (  # noqa
     field_modifier,
     maybe_post_init,
     opt_repr,
+    update_class_metadata,
     update_field_extras,
     update_field_metadata,
     update_fields,

omlish/dataclasses/impl/init.py

@@ -130,9 +130,17 @@ class InitBuilder:
             cas = ', '.join(p.name for p in csig.parameters.values())
             body_lines.append(f'if not {cn}({cas}): raise __dataclass_CheckError__')
 
-        for i, fn in enumerate(self._info.merged_metadata.get(Init, [])):
+        inits = self._info.merged_metadata.get(Init, [])
+        mro_dct = lang.build_mro_dict(self._info.cls)
+        mro_v_ids = set(map(id, mro_dct.values()))
+        props_by_fget_id = {id(v.fget): v for v in mro_dct.values() if isinstance(v, property) and v.fget is not None}
+        for i, obj in enumerate(inits):
+            if (obj_id := id(obj)) not in mro_v_ids and obj_id in props_by_fget_id:
+                obj = props_by_fget_id[obj_id].__get__
+            elif isinstance(obj, property):
+                obj = obj.__get__
             cn = f'__dataclass_init_{i}__'
-            locals[cn] = fn
+            locals[cn] = obj
             body_lines.append(f'{cn}({self._self_name})')
 
         if not body_lines:

omlish/dataclasses/impl/metadata.py

@@ -70,6 +70,6 @@ class Init(lang.Marker):
     pass
 
 
-def init(fn: ta.Callable):
-    _append_cls_md(Init, fn)
-    return fn
+def init(obj):
+    _append_cls_md(Init, obj)
+    return obj

omlish/dataclasses/impl/reflect.py

@@ -149,7 +149,7 @@ class ClassInfo:
 
     @cached.property
     def generic_mro_lookup(self) -> ta.Mapping[type, rfl.Type]:
-        return col.unique_map(((check.not_none(rfl.get_concrete_type(g)), g) for g in self.generic_mro), strict=True)
+        return col.make_map(((check.not_none(rfl.get_concrete_type(g)), g) for g in self.generic_mro), strict=True)
 
     @cached.property
     def generic_replaced_field_types(self) -> ta.Mapping[str, rfl.Type]:

omlish/dataclasses/utils.py

@@ -4,6 +4,8 @@ import types
 import typing as ta
 
 from .. import check
+from .impl.metadata import METADATA_ATTR
+from .impl.metadata import UserMetadata
 from .impl.params import DEFAULT_FIELD_EXTRAS
 from .impl.params import FieldExtras
 from .impl.params import get_field_extras
@@ -50,6 +52,13 @@ def chain_metadata(*mds: ta.Mapping) -> types.MappingProxyType:
     return types.MappingProxyType(collections.ChainMap(*mds))  # type: ignore  # noqa
 
 
+def update_class_metadata(cls: type[T], *args: ta.Any) -> type[T]:
+    check.isinstance(cls, type)
+    setattr(cls, METADATA_ATTR, md := getattr(cls, METADATA_ATTR, {}))
+    md.setdefault(UserMetadata, []).extend(args)
+    return cls
+
+
 def update_field_metadata(f: dc.Field, nmd: ta.Mapping) -> dc.Field:
     check.isinstance(f, dc.Field)
     f.metadata = chain_metadata(nmd, f.metadata)
@@ -79,9 +88,13 @@ def update_fields(
 
         else:
             for a in fields:
-                v = cls.__dict__[a]
-                if not isinstance(v, dc.Field):
-                    v = dc.field(default=v)
+                try:
+                    v = cls.__dict__[a]
+                except KeyError:
+                    v = dc.field()
+                else:
+                    if not isinstance(v, dc.Field):
+                        v = dc.field(default=v)
                 setattr(cls, a, fn(a, v))
 
         return cls

omlish/diag/pycharm.py

@@ -17,6 +17,16 @@ else:
 ##
 
 
+PYCHARM_HOSTED_ENV_VAR = 'PYCHARM_HOSTED'
+
+
+def is_pycharm_hosted() -> bool:
+    return PYCHARM_HOSTED_ENV_VAR in os.environ
+
+
+##
+
+
 PYCHARM_HOME = '/Applications/PyCharm.app'
 
 
@@ -45,6 +55,53 @@ def get_pycharm_version() -> str | None:
 ##
 
 
+def _import_pydevd_pycharm(*, version: str | None = None) -> ta.Any:
+    if (
+            'pydevd_pycharm' in sys.modules or
+            (version is None and lang.can_import('pydevd_pycharm'))
+    ):
+        # Can't unload, nothing we can do
+        import pydevd_pycharm  # noqa
+        return pydevd_pycharm
+
+    proc = subprocess.run([  # noqa
+        sys.executable,
+        '-m', 'pip',
+        'show',
+        'pydevd_pycharm',
+    ], stdout=subprocess.PIPE)
+
+    if not proc.returncode:
+        info = {
+            k: v.strip()
+            for l in proc.stdout.decode().splitlines()
+            if (s := l.strip())
+            for k, _, v in [s.partition(':')]
+        }
+
+        installed_version = info['Version']
+        if installed_version == version:
+            import pydevd_pycharm  # noqa
+            return pydevd_pycharm
+
+        subprocess.check_call([
+            sys.executable,
+            '-m', 'pip',
+            'uninstall', '-y',
+            'pydevd_pycharm',
+        ])
+
+    subprocess.check_call([
+        sys.executable,
+        '-m', 'pip',
+        'install',
+        'pydevd_pycharm' + (f'=={version}' if version is not None else ''),
+    ])
+
+    import pydevd_pycharm  # noqa
+    return pydevd_pycharm
+
+
 def pycharm_remote_debugger_attach(
         host: str | None,
         port: int,
@@ -56,25 +113,27 @@ def pycharm_remote_debugger_attach(
     # check.non_empty_str(version)
 
     if host is None:
-        if sys.platform == 'linux' and docker.is_likely_in_docker():
+        if (
+                sys.platform == 'linux' and
+                docker.is_likely_in_docker() and
+                docker.get_docker_host_platform() == 'darwin'
+        ):
             host = docker.DOCKER_FOR_MAC_HOSTNAME
         else:
             host = 'localhost'
 
-    try:
+    if ta.TYPE_CHECKING:
         import pydevd_pycharm  # noqa
-    except ImportError:
-        subprocess.check_call([
-            sys.executable,
-            '-mpip',
-            'install',
-            'pydevd-pycharm' + (f'~={version}' if version is not None else ''),
-        ])
+    else:
+        pydevd_pycharm = _import_pydevd_pycharm(version=version)
 
-    import pydevd_pycharm  # noqa
     pydevd_pycharm.settrace(
         host,
         port=port,
         stdoutToServer=True,
         stderrToServer=True,
     )
+
+
+if __name__ == '__main__':
+    print(get_pycharm_version())

omlish/docker.py

@@ -15,6 +15,7 @@ apil="application/vnd.docker.distribution.manifest.list.v2+json"
 curl -H "Accept: ${api}" -H "Accept: ${apil}" -H "Authorization: Bearer $token" -s "https://registry-1.docker.io/v2/${repo}/manifests/latest" | jq .
 """  # noqa
 import datetime
+import os
 import re
 import shlex
 import subprocess
@@ -38,15 +39,12 @@ else:
 
 
 @dc.dataclass(frozen=True)
+@msh.update_object_metadata(field_naming=msh.Naming.CAMEL, unknown_field='x')
+@msh.update_fields_metadata(['id'], name='ID')
 class PsItem(lang.Final):
-    dc.metadata(msh.ObjectMetadata(
-        field_naming=msh.Naming.CAMEL,
-        unknown_field='x',
-    ))
-
     command: str
     created_at: datetime.datetime
-    id: str = dc.field(metadata={msh.FieldMetadata: msh.FieldMetadata(name='ID')})
+    id: str
     image: str
     labels: str
     local_volumes: str
@@ -101,12 +99,8 @@ def cli_ps() -> list[PsItem]:
 
 
 @dc.dataclass(frozen=True)
+@msh.update_object_metadata(field_naming=msh.Naming.CAMEL, unknown_field='x')
 class Inspect(lang.Final):
-    dc.metadata(msh.ObjectMetadata(
-        field_naming=msh.Naming.CAMEL,
-        unknown_field='x',
-    ))
-
     id: str
     created: datetime.datetime
 
@@ -186,3 +180,14 @@ def is_likely_in_docker() -> bool:
     with open('/proc/mounts') as f:  # type: ignore
         ls = f.readlines()
     return any(_LIKELY_IN_DOCKER_PATTERN.match(l) for l in ls)
+
+
+##
+
+
+# Set by pyproject, docker-dev script
+DOCKER_HOST_PLATFORM_KEY = 'DOCKER_HOST_PLATFORM'
+
+
+def get_docker_host_platform() -> str | None:
+    return os.environ.get(DOCKER_HOST_PLATFORM_KEY)