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

omlish/concurrent/__init__.py

@@ -0,0 +1,11 @@
+from .executors import (  # noqa
+    ImmediateExecutor,
+    new_executor,
+)
+
+from .futures import (  # noqa
+    FutureError,
+    FutureTimeoutError,
+    wait_futures,
+    wait_dependent_futures,
+)

omlish/concurrent/executors.py

@@ -0,0 +1,52 @@
+import concurrent.futures as cf
+import contextlib
+import typing as ta
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+class ImmediateExecutor(cf.Executor):
+
+    def __init__(self, *, immediate_exceptions: bool = False) -> None:
+        super().__init__()
+        self._immediate_exceptions = immediate_exceptions
+
+    def submit(
+            self,
+            fn: ta.Callable[P, T],
+            /,
+            *args: P.args,
+            **kwargs: P.kwargs,
+    ) -> cf.Future[T]:
+        future: ta.Any = cf.Future()
+        try:
+            result = fn(*args, **kwargs)
+            future.set_result(result)
+        except Exception as e:
+            if self._immediate_exceptions:
+                raise
+            future.set_exception(e)
+        return future
+
+
+@contextlib.contextmanager
+def new_executor(
+        max_workers: int | None = None,
+        cls: type[cf.Executor] = cf.ThreadPoolExecutor,
+        *,
+        immediate_exceptions: bool = False,
+        **kwargs: ta.Any,
+) -> ta.Generator[cf.Executor, None, None]:
+    if max_workers == 0:
+        yield ImmediateExecutor(
+            immediate_exceptions=immediate_exceptions,
+        )
+
+    else:
+        with cls(  # type: ignore
+                max_workers,
+                **kwargs,
+        ) as exe:
+            yield exe

omlish/{concurrent.py → concurrent/futures.py}

@@ -1,11 +1,9 @@
 import concurrent.futures as cf
-import contextlib
 import time
 import typing as ta
 
 
 T = ta.TypeVar('T')
-P = ta.ParamSpec('P')
 
 
 ##
@@ -137,45 +135,3 @@ def wait_dependent_futures(
 
     futs_by_fn = {fn: fut for fut, fn in fns_by_fut.items()}
     return futs_by_fn
-
-
-##
-
-
-class ImmediateExecutor(cf.Executor):
-
-    def __init__(self, *, immediate_exceptions: bool = False) -> None:
-        super().__init__()
-        self._immediate_exceptions = immediate_exceptions
-
-    def submit(self, fn: ta.Callable[P, T], /, *args: P.args, **kwargs: P.kwargs) -> cf.Future[T]:
-        future: ta.Any = cf.Future()
-        try:
-            result = fn(*args, **kwargs)
-            future.set_result(result)
-        except Exception as e:
-            if self._immediate_exceptions:
-                raise
-            future.set_exception(e)
-        return future
-
-
-@contextlib.contextmanager
-def new_executor(
-        max_workers: int | None = None,
-        cls: type[cf.Executor] = cf.ThreadPoolExecutor,
-        *,
-        immediate_exceptions: bool = False,
-        **kwargs: ta.Any,
-) -> ta.Generator[cf.Executor, None, None]:
-    if max_workers == 0:
-        yield ImmediateExecutor(
-            immediate_exceptions=immediate_exceptions,
-        )
-
-    else:
-        with cls(  # type: ignore
-                max_workers,
-                **kwargs,
-        ) as exe:
-            yield exe

omlish/concurrent/threadlets.py

@@ -0,0 +1,91 @@
+import abc
+import dataclasses as dc
+import typing as ta
+
+from omlish import lang
+
+
+if ta.TYPE_CHECKING:
+    import greenlet
+else:
+    greenlet = lang.proxy_import('greenlet')
+
+
+##
+
+
+class Threadlet(abc.ABC):
+    """Not safe to identity-key - use `underlying`."""
+
+    def __hash__(self):
+        raise TypeError('use `underlying`')
+
+    def __eq__(self, other):
+        raise TypeError('use `underlying`')
+
+    @property
+    @abc.abstractmethod
+    def underlying(self) -> ta.Any:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def parent(self) -> ta.Optional['Threadlet']:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def dead(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def switch(self, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def throw(self, ex: Exception) -> ta.Any:
+        raise NotImplementedError
+
+
+class Threadlets(abc.ABC):
+    @abc.abstractmethod
+    def spawn(self, fn: ta.Callable[[], None]) -> Threadlet:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_current(self) -> Threadlet:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class GreenletThreadlet(Threadlet):
+    g: 'greenlet.greenlet'
+
+    @property
+    def underlying(self) -> 'greenlet.greenlet':
+        return self.g
+
+    @property
+    def parent(self) -> ta.Optional['GreenletThreadlet']:
+        return GreenletThreadlet(self.g.parent)
+
+    @property
+    def dead(self) -> bool:
+        return self.g.dead
+
+    def switch(self, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        return self.g.switch(*args, **kwargs)
+
+    def throw(self, ex: Exception) -> ta.Any:
+        return self.g.throw(ex)
+
+
+class GreenletThreadlets(Threadlets):
+    def spawn(self, fn: ta.Callable[[], None]) -> Threadlet:
+        return GreenletThreadlet(greenlet.greenlet(fn))
+
+    def get_current(self) -> Threadlet:
+        return GreenletThreadlet(greenlet.getcurrent())

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,80 @@
+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_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 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():
+            host = docker.DOCKER_FOR_MAC_HOSTNAME
+        else:
+            host = 'localhost'
+
+    try:
+        import pydevd_pycharm  # noqa
+    except ImportError:
+        subprocess.check_call([
+            sys.executable,
+            '-mpip',
+            'install',
+            'pydevd-pycharm' + (f'~={version}' if version is not None else ''),
+        ])
+
+    import pydevd_pycharm  # noqa
+    pydevd_pycharm.settrace(
+        host,
+        port=port,
+        stdoutToServer=True,
+        stderrToServer=True,
+    )

omlish/docker.py

@@ -174,6 +174,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/')
 
 

omlish/genmachine.py

@@ -0,0 +1,58 @@
+"""
+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/lang/functions.py

@@ -108,6 +108,9 @@ def issubclass_of(class_or_tuple: ta.Any) -> ta.Callable[[ta.Any], bool]:
     return lambda o: issubclass(o, class_or_tuple)
 
 
+##
+
+
 class VoidError(Exception):
     pass
 

omlish/logs/__init__.py

@@ -8,6 +8,10 @@ from .formatters import (  # noqa
     StandardLogFormatter,
 )
 
+from .handlers import (  # noqa
+    ListHandler,
+)
+
 from .utils import (  # noqa
     error_logging,
 )

omlish/logs/handlers.py

@@ -0,0 +1,10 @@
+import logging
+
+
+class ListHandler(logging.Handler):
+    def __init__(self) -> None:
+        super().__init__()
+        self.records: list[logging.LogRecord] = []
+
+    def emit(self, record):
+        self.records.append(record)

omlish/marshal/__init__.py

@@ -65,6 +65,10 @@ from .polymorphism import (  # noqa
     polymorphism_from_subclasses,
 )
 
+from .primitives import (  # noqa
+    PRIMITIVE_TYPES,
+)
+
 from .registries import (  # noqa
     Registry,
 )

omlish/marshal/base64.py

@@ -1,3 +1,7 @@
+"""
+FIXME:
+ - don't base64 by default, only for json-esque targets
+"""
 import base64
 import typing as ta
 

omlish/marshal/primitives.py

@@ -9,6 +9,9 @@ from .base import Unmarshaler
 from .values import Value
 
 
+##
+
+
 PRIMITIVE_TYPES: tuple[type, ...] = (
     bool,
     int,
@@ -19,6 +22,9 @@ PRIMITIVE_TYPES: tuple[type, ...] = (
 )
 
 
+##
+
+
 class PrimitiveMarshalerUnmarshaler(Marshaler, Unmarshaler):
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
         if isinstance(o, PRIMITIVE_TYPES):

omlish/marshal/standard.py

@@ -27,6 +27,8 @@ from .optionals import OptionalMarshalerFactory
 from .optionals import OptionalUnmarshalerFactory
 from .primitives import PRIMITIVE_MARSHALER_FACTORY
 from .primitives import PRIMITIVE_UNMARSHALER_FACTORY
+from .unions import PrimitiveUnionMarshalerFactory
+from .unions import PrimitiveUnionUnmarshalerFactory
 from .uuids import UUID_MARSHALER_FACTORY
 from .uuids import UUID_UNMARSHALER_FACTORY
 
@@ -37,6 +39,7 @@ from .uuids import UUID_UNMARSHALER_FACTORY
 STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     PRIMITIVE_MARSHALER_FACTORY,
     OptionalMarshalerFactory(),
+    PrimitiveUnionMarshalerFactory(),
     DataclassMarshalerFactory(),
     EnumMarshalerFactory(),
     NUMBERS_MARSHALER_FACTORY,
@@ -66,6 +69,7 @@ def new_standard_marshaler_factory() -> MarshalerFactory:
 STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     PRIMITIVE_UNMARSHALER_FACTORY,
     OptionalUnmarshalerFactory(),
+    PrimitiveUnionUnmarshalerFactory(),
     DataclassUnmarshalerFactory(),
     EnumUnmarshalerFactory(),
     NUMBERS_UNMARSHALER_FACTORY,

omlish/marshal/unions.py

@@ -0,0 +1,101 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import check
+from .. import matchfns as mfs
+from .. import reflect as rfl
+from .base import MarshalContext
+from .base import Marshaler
+from .base import MarshalerFactory
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .values import Value
+
+
+##
+
+
+class MatchUnionMarshaler(Marshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        try:
+            m = self.mmf.match(ctx, o)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(o)  # noqa
+        return m.fn(ctx, o)
+
+
+class MatchUnionUnmarshaler(Unmarshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        try:
+            m = self.mmf.match(ctx, v)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(v)  # noqa
+        return m.fn(ctx, v)
+
+
+##
+
+
+PRIMITIVE_UNION_TYPES: tuple[type, ...] = (
+    float,
+    int,
+    str,
+)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshaler(Marshaler):
+    tys: ta.Sequence[type]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshalerFactory(MarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and all(a in self.tys for a in rty.args)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        args = check.isinstance(rty, rfl.Union).args
+        return PrimitiveUnionMarshaler([t for t in self.tys if t in args])
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshaler(Unmarshaler):
+    tys: ta.Sequence[type]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshalerFactory(UnmarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and all(a in self.tys for a in rty.args)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        args = check.isinstance(rty, rfl.Union).args
+        return PrimitiveUnionUnmarshaler([t for t in self.tys if t in args])
+
+
+#
+
+
+PRIMITIVE_UNION_MARSHALER_FACTORY = PrimitiveUnionMarshalerFactory()
+PRIMITIVE_UNION_UNMARSHALER_FACTORY = PrimitiveUnionUnmarshalerFactory()