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

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/asts.py

@@ -0,0 +1,132 @@
+import ast
+import dataclasses as dc
+import inspect
+import pprint
+import textwrap
+import types
+import typing as ta
+
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import executing
+else:
+    executing = lang.proxy_import('executing')
+
+
+class ArgsRenderer:
+    """
+    TODO:
+     - kwargs
+     - recursion
+     - whatever pytest looks like
+     - make sure not leaking sensitive data
+    """
+
+    def __init__(
+            self,
+            origin: types.TracebackType | types.FrameType | None = None,
+            back: int = 1,
+    ) -> None:
+        super().__init__()
+
+        self._origin = origin
+
+        self._frame: types.FrameType | None
+        if isinstance(origin, types.TracebackType):
+            self._frame = origin.tb_frame
+        elif isinstance(origin, types.FrameType):
+            self._frame = origin
+        elif origin is None:
+            frame = inspect.currentframe()
+            for _ in range(back + 1):
+                if frame is None:
+                    break
+                frame = frame.f_back
+            self._frame = frame
+        else:
+            raise TypeError(origin)
+
+    def _get_indented_text(
+            self,
+            src: executing.Source,
+            node: ast.AST,
+    ) -> str:
+        result = src.asttokens().get_text(node)
+        if '\n' in result:
+            result = ' ' * node.first_token.start[1] + result  # type: ignore
+            result = textwrap.dedent(result)
+        result = result.strip()
+        return result
+
+    def _val_to_string(self, obj: ta.Any) -> str:
+        s = pprint.pformat(obj)
+        s = s.replace('\\n', '\n')
+        return s
+
+    def _is_literal_expr(self, s: str) -> bool:
+        try:
+            ast.literal_eval(s)
+        except Exception:  # noqa
+            return False
+        return True
+
+    @dc.dataclass(frozen=True)
+    class RenderedArg:
+        val: str
+        expr: str
+        is_literal_expr: bool
+
+        def __str__(self) -> str:
+            if self.is_literal_expr:
+                return self.val
+            else:
+                return f'({self.expr} = {self.val})'
+
+    def render_args(
+            self,
+            *vals: ta.Any,
+    ) -> ta.Sequence[RenderedArg] | None:
+        if self._frame is None:
+            return None
+
+        call_node = executing.Source.executing(self._frame).node
+        if not isinstance(call_node, ast.Call):
+            return None
+
+        source = executing.Source.for_frame(self._frame)
+
+        exprs = [
+            self._get_indented_text(source, arg)  # noqa
+            for arg in call_node.args
+        ]
+        if len(exprs) != len(vals):
+            return None
+
+        return [
+            self.RenderedArg(
+                val=self._val_to_string(val),
+                expr=expr,
+                is_literal_expr=self._is_literal_expr(expr),
+            )
+            for val, expr in zip(vals, exprs)
+        ]
+
+    @classmethod
+    def smoketest(cls) -> bool:
+        def bar(z):
+            return z + 1
+
+        def foo(x, y):
+            return cls().render_args(x, y)
+
+        r = foo(1, bar(2))
+        if r is None:
+            return False
+
+        x, y = r
+        return (
+            x == cls.RenderedArg(val='1', expr='1', is_literal_expr=True) and
+            y == cls.RenderedArg(val='3', expr='bar(2)', is_literal_expr=False)
+        )

omlish/diag/pycharm.py

@@ -0,0 +1,139 @@
+import os.path
+import plistlib
+import subprocess
+import sys
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    docker = lang.proxy_import('omlish.docker')
+else:
+    from omlish import docker
+
+
+##
+
+
+PYCHARM_HOSTED_ENV_VAR = 'PYCHARM_HOSTED'
+
+
+def is_pycharm_hosted() -> bool:
+    return PYCHARM_HOSTED_ENV_VAR in os.environ
+
+
+##
+
+
+PYCHARM_HOME = '/Applications/PyCharm.app'
+
+
+def read_pycharm_info_plist() -> ta.Mapping[str, ta.Any] | None:
+    plist_file = os.path.join(PYCHARM_HOME, 'Contents', 'Info.plist')
+    if not os.path.isfile(plist_file):
+        return None
+
+    with open(plist_file, 'rb') as f:
+        root = plistlib.load(f)
+
+    return root
+
+
+@lang.cached_function
+def get_pycharm_version() -> str | None:
+    plist = read_pycharm_info_plist()
+    if plist is None:
+        return None
+
+    ver = check.non_empty_str(plist['CFBundleVersion'])
+    check.state(ver.startswith('PY-'))
+    return ver[3:]
+
+
+##
+
+
+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,
+        *,
+        version: str | None = None,
+) -> None:
+    # if version is None:
+    #     version = get_pycharm_version()
+    # check.non_empty_str(version)
+
+    if host is None:
+        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'
+
+    if ta.TYPE_CHECKING:
+        import pydevd_pycharm  # noqa
+    else:
+        pydevd_pycharm = _import_pydevd_pycharm(version=version)
+
+    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
 
@@ -174,6 +168,9 @@ def timebomb_payload(delay_s: float, name: str = 'omlish-docker-timebomb') -> st
 ##
 
 
+DOCKER_FOR_MAC_HOSTNAME = 'docker.for.mac.localhost'
+
+
 _LIKELY_IN_DOCKER_PATTERN = re.compile(r'^overlay / .*/docker/')
 
 
@@ -183,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)

omlish/genmachine.py

@@ -0,0 +1,59 @@
+"""
+See:
+ - https://github.com/pytransitions/transitions
+"""
+import typing as ta
+
+
+I = ta.TypeVar('I')
+O = ta.TypeVar('O')
+
+# MachineGen: ta.TypeAlias = ta.Generator[ta.Iterable[O] | None, I, ta.Optional[MachineGen[I, O]]]
+MachineGen: ta.TypeAlias = ta.Generator[ta.Any, ta.Any, ta.Any]
+
+
+##
+
+
+class IllegalStateError(Exception):
+    pass
+
+
+class GenMachine(ta.Generic[I, O]):
+    """
+    Generator-powered state machine. Generators are sent an `I` object and yield any number of `O` objects in response,
+    until they yield a `None` by accepting new input. Generators may return a new generator to switch states, or return
+    `None` to terminate.
+    """
+
+    def __init__(self, initial: MachineGen) -> None:
+        super().__init__()
+        self._advance(initial)
+
+    @property
+    def state(self) -> str | None:
+        if self._gen is not None:
+            return self._gen.gi_code.co_qualname
+        return None
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{hex(id(self))[2:]}<{self.state}>'
+
+    _gen: MachineGen | None
+
+    def _advance(self, gen: MachineGen) -> None:
+        self._gen = gen
+        if (n := next(self._gen)) is not None:  # noqa
+            raise IllegalStateError
+
+    def __call__(self, i: I) -> ta.Iterable[O]:
+        if self._gen is None:
+            raise IllegalStateError
+        try:
+            while (o := self._gen.send(i)) is not None:
+                yield from o
+        except StopIteration as s:
+            if s.value is None:
+                self._gen = None
+                return None
+            self._advance(s.value)

omlish/graphs/trees.py

@@ -190,7 +190,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         e: ta.Any
         d: ta.Any
         if identity:
-            e, d = id, col.unique_map(((id(n), n) for n, _ in pairs), strict=True)
+            e, d = id, col.make_map(((id(n), n) for n, _ in pairs), strict=True)
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}

omlish/lang/__init__.py

@@ -79,7 +79,7 @@ from .descriptors import (  # noqa
     unwrap_func,
     unwrap_func_with_partials,
     unwrap_method_descriptors,
-    update_wrapper_except_dict,
+    update_wrapper,
 )
 
 from .exceptions import (  # noqa
@@ -154,6 +154,18 @@ from .objects import (  # noqa
     super_meta,
 )
 
+from .resolving import (  # noqa
+    Resolvable,
+    ResolvableClassNameError,
+    get_cls_fqcn,
+    get_fqcn_cls,
+)
+
+from .resources import (  # noqa
+    RelativeResource,
+    get_relative_resources,
+)
+
 from .strings import (  # noqa
     BOOL_FALSE_STRINGS,
     BOOL_STRINGS,

omlish/lang/cached.py

@@ -220,7 +220,7 @@ def cached_function(fn=None, **kwargs):  # noqa
 ##
 
 
-class _CachedProperty:
+class _CachedProperty(property):
     def __init__(
             self,
             fn,
@@ -229,9 +229,9 @@ class _CachedProperty:
             ignore_if=lambda _: False,
             clear_on_init=False,
     ):
-        super().__init__()
         if isinstance(fn, property):
             fn = fn.fget
+        super().__init__(fn)
         self._fn = fn
         self._ignore_if = ignore_if
         self._name = name
@@ -265,6 +265,9 @@ class _CachedProperty:
             return
         raise TypeError(self._name)
 
+    def __delete__(self, instance):
+        raise TypeError
+
 
 def cached_property(fn=None, **kwargs):  # noqa
     if fn is None:

omlish/lang/descriptors.py

@@ -91,21 +91,38 @@ def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functo
 ##
 
 
-WRAPPER_UPDATES_EXCEPT_DICT = tuple(a for a in functools.WRAPPER_UPDATES if a != '__dict__')
+def update_wrapper(
+        wrapper: T,
+        wrapped: ta.Any,
+        assigned: ta.Iterable[str] = functools.WRAPPER_ASSIGNMENTS,
+        updated: ta.Iterable[str] = functools.WRAPPER_UPDATES,
+        *,
+        filter: ta.Iterable[str] | None = None,  # noqa
+        getattr: ta.Callable = getattr,  # noqa
+        setattr: ta.Callable = setattr,  # noqa
+) -> T:
+    if filter:
+        if isinstance(filter, str):
+            filter = [filter]  # noqa
+        assigned = tuple(a for a in assigned if a not in filter)
+        updated = tuple(a for a in updated if a not in filter)
+
+    for attr in assigned:
+        try:
+            value = getattr(wrapped, attr)
+        except AttributeError:
+            pass
+        else:
+            setattr(wrapper, attr, value)
+
+    for attr in updated:
+        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
 
+    # Issue #17482: set __wrapped__ last so we don't inadvertently copy it from the wrapped function when updating
+    # __dict__
+    setattr(wrapper, '__wrapped__', wrapped)
 
-def update_wrapper_except_dict(
-        wrapper,
-        wrapped,
-        assigned=functools.WRAPPER_ASSIGNMENTS,
-        updated=WRAPPER_UPDATES_EXCEPT_DICT,
-):
-    return functools.update_wrapper(
-        wrapper,
-        wrapped,
-        assigned=assigned,
-        updated=updated,
-    )
+    return wrapper
 
 
 ##
@@ -118,7 +135,7 @@ class _decorator_descriptor:  # noqa
     if not _DECORATOR_HANDLES_UNBOUND_METHODS:
         def __init__(self, wrapper, fn):
             self._wrapper, self._fn = wrapper, fn
-            update_wrapper_except_dict(self, fn)
+            update_wrapper(self, fn, filter='__dict__')
 
         def __get__(self, instance, owner=None):
             return functools.update_wrapper(functools.partial(self._wrapper, fn := self._fn.__get__(instance, owner)), fn)  # noqa
@@ -127,7 +144,7 @@ class _decorator_descriptor:  # noqa
         def __init__(self, wrapper, fn):
             self._wrapper, self._fn = wrapper, fn
             self._md = _has_method_descriptor(fn)
-            update_wrapper_except_dict(self, fn)
+            update_wrapper(self, fn, filter='__dict__')
 
         def __get__(self, instance, owner=None):
             fn = self._fn.__get__(instance, owner)
@@ -157,7 +174,7 @@ class _decorator_descriptor:  # noqa
 class _decorator:  # noqa
     def __init__(self, wrapper):
         self._wrapper = wrapper
-        update_wrapper_except_dict(self, wrapper)
+        update_wrapper(self, wrapper, filter='__dict__')
 
     def __repr__(self):
         return f'{self.__class__.__name__}<{self._wrapper}>'