omlish 0.0.0.dev315__py3-none-any.whl → 0.0.0.dev317__py3-none-any.whl

omlish/lite/maybes.py

@@ -1,15 +1,23 @@
+# ruff: noqa: UP007
 import abc
 import functools
 import typing as ta
 
 
 T = ta.TypeVar('T')
+U = ta.TypeVar('U')
 
 
 ##
 
 
+@functools.total_ordering
 class Maybe(ta.Generic[T]):
+    class ValueNotPresentError(BaseException):
+        pass
+
+    #
+
     @property
     @abc.abstractmethod
     def present(self) -> bool:
@@ -19,9 +27,102 @@ class Maybe(ta.Generic[T]):
     def must(self) -> T:
         raise NotImplementedError
 
+    #
+
+    @abc.abstractmethod
+    def __repr__(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __eq__(self, other) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __lt__(self, other) -> bool:
+        raise NotImplementedError
+
+    #
+
+    @ta.final
+    def __ne__(self, other):
+        return not (self == other)
+
+    @ta.final
+    def __iter__(self) -> ta.Iterator[T]:
+        if self.present:
+            yield self.must()
+
+    @ta.final
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError
+
+    #
+
+    @ta.final
+    def if_present(self, consumer: ta.Callable[[T], None]) -> None:
+        if self.present:
+            consumer(self.must())
+
+    @ta.final
+    def filter(self, predicate: ta.Callable[[T], bool]) -> 'Maybe[T]':
+        if self.present and predicate(self.must()):
+            return self
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def map(self, mapper: ta.Callable[[T], U]) -> 'Maybe[U]':
+        if self.present:
+            return Maybe.just(mapper(self.must()))
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def flat_map(self, mapper: ta.Callable[[T], 'Maybe[U]']) -> 'Maybe[U]':
+        if self.present:
+            if not isinstance(v := mapper(self.must()), Maybe):
+                raise TypeError(v)
+            return v
+        else:
+            return Maybe.empty()
+
+    @ta.final
+    def or_else(self, other: ta.Union[T, U]) -> ta.Union[T, U]:
+        if self.present:
+            return self.must()
+        else:
+            return other
+
+    @ta.final
+    def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
+        if self.present:
+            return self.must()
+        else:
+            return supplier()
+
+    @ta.final
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:
+        if self.present:
+            return self.must()
+        else:
+            raise exception_supplier()
+
+    #
+
+    @classmethod
+    def of_optional(cls, v: ta.Optional[T]) -> 'Maybe[T]':
+        if v is not None:
+            return cls.just(v)
+        else:
+            return cls.empty()
+
     @classmethod
     def just(cls, v: T) -> 'Maybe[T]':
-        return tuple.__new__(_Maybe, (v,))  # noqa
+        return _JustMaybe(v)
 
     _empty: ta.ClassVar['Maybe']
 
@@ -30,33 +131,78 @@ class Maybe(ta.Generic[T]):
         return Maybe._empty
 
 
-class _Maybe(Maybe[T], tuple):
-    __slots__ = ()
+##
+
+
+class _Maybe(Maybe[T], abc.ABC):
+    def __lt__(self, other):
+        if not isinstance(other, _Maybe):
+            return NotImplemented
+        sp = self.present
+        op = other.present
+        if self.present and other.present:
+            return self.must() < other.must()
+        else:
+            return op and not sp
 
-    def __init_subclass__(cls, **kwargs):
-        raise TypeError
+
+class _JustMaybe(_Maybe[T]):
+    __slots__ = ('_v', '_hash')
+
+    def __init__(self, v: T) -> None:
+        super().__init__()
+
+        self._v = v
 
     @property
     def present(self) -> bool:
-        return bool(self)
+        return True
 
     def must(self) -> T:
-        if not self:
-            raise ValueError
-        return self[0]
+        return self._v
 
+    #
 
-Maybe._empty = tuple.__new__(_Maybe, ())  # noqa
+    def __repr__(self) -> str:
+        return f'just({self._v!r})'
 
+    _hash: int
 
-##
+    def __hash__(self) -> int:
+        try:
+            return self._hash
+        except AttributeError:
+            pass
+        h = self._hash = hash((_JustMaybe, self._v))
+        return h
+
+    def __eq__(self, other):
+        return (
+            self.__class__ is other.__class__ and
+            self._v == other._v  # noqa
+        )
+
+
+class _EmptyMaybe(_Maybe[T]):
+    __slots__ = ()
+
+    @property
+    def present(self) -> bool:
+        return False
+
+    def must(self) -> T:
+        raise Maybe.ValueNotPresentError
+
+    #
+
+    def __repr__(self) -> str:
+        return 'empty()'
 
+    def __hash__(self) -> int:
+        return hash(_EmptyMaybe)
 
-@functools.singledispatch
-def as_maybe(obj: ta.Any) -> Maybe:
-    raise TypeError(obj)
+    def __eq__(self, other):
+        return self.__class__ is other.__class__
 
 
-@as_maybe.register
-def _(obj: Maybe) -> Maybe:
-    return obj
+Maybe._empty = _EmptyMaybe()  # noqa

omlish/logs/callers.py

@@ -7,6 +7,9 @@ import types
 import typing as ta
 
 
+##
+
+
 class LoggingCaller(ta.NamedTuple):
     filename: str
     lineno: int

omlish/logs/color.py

@@ -6,6 +6,9 @@ from ..term import codes as tc
 from .standard import StandardLogFormatter
 
 
+##
+
+
 class ColorLogFormatter(StandardLogFormatter):
     LEVEL_COLORS: ta.Mapping[int, tc.SGRs.FG] = {
         logging.WARNING: tc.SGRs.FG.BRIGHT_YELLOW,

omlish/logs/filters.py

@@ -4,7 +4,14 @@ import logging
 import threading
 
 
+##
+
+
 class TidLogFilter(logging.Filter):
     def filter(self, record):
-        record.tid = threading.get_native_id()
+        # FIXME: handle better - missing from wasm and cosmos
+        if hasattr(threading, 'get_native_id'):
+            record.tid = threading.get_native_id()
+        else:
+            record.tid = '?'
         return True

omlish/logs/handlers.py

@@ -4,6 +4,9 @@ import logging
 import typing as ta
 
 
+##
+
+
 class ListHandler(logging.Handler):
     def __init__(self) -> None:
         super().__init__()

omlish/logs/json.py

@@ -10,6 +10,9 @@ import typing as ta
 from ..lite.json import json_dumps_compact
 
 
+##
+
+
 class JsonLogFormatter(logging.Formatter):
     KEYS: ta.Mapping[str, bool] = {
         'name': False,

omlish/logs/noisy.py

@@ -1,6 +1,9 @@
 import logging
 
 
+##
+
+
 NOISY_LOGGERS: set[str] = {
     'boto3.resources.action',
     'datadog.dogstatsd',

omlish/logs/proxy.py

@@ -3,6 +3,9 @@
 import logging
 
 
+##
+
+
 class ProxyLogFilterer(logging.Filterer):
     def __init__(self, underlying: logging.Filterer) -> None:  # noqa
         self._underlying = underlying

omlish/logs/utils.py

@@ -2,6 +2,9 @@ import functools
 import logging
 
 
+##
+
+
 _log = logging.getLogger(__name__)
 
 

omlish/sockets/ports.py

@@ -16,21 +16,38 @@ DEFAULT_AVAILABLE_PORT_HOST: str = '127.0.0.1'
 
 
 @contextlib.contextmanager
-def get_available_port_context(host: ta.Optional[str] = None) -> ta.Iterator[int]:
+def get_available_port_context(
+        host: ta.Optional[str] = None,
+        family: int = socket.AF_INET,
+        type: int = socket.SOCK_STREAM,  # noqa
+        *,
+        listen: ta.Union[bool, int, None] = False,
+) -> ta.Iterator[int]:
     if host is None:
         host = DEFAULT_AVAILABLE_PORT_HOST
 
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+    if listen is not None:
+        if listen is True:
+            listen = 1
+        elif listen is False:
+            listen = None
+        else:
+            listen = check.isinstance(listen, int)
+
+    with socket.socket(family, type) as sock:
         sock.bind((host, 0))
-        sock.listen(1)
+
+        if listen is not None:
+            sock.listen(listen)
+
         port = sock.getsockname()[1]
+
         yield port
 
 
-def get_available_port(host: ta.Optional[str] = None) -> int:
-    with get_available_port_context(host) as port:
-        pass
-    return port
+def get_available_port(*args: ta.Any, **kwargs: ta.Any) -> int:
+    with get_available_port_context(*args, **kwargs) as port:
+        return port
 
 
 def get_available_ports(

omlish/testing/pytest/plugins/switches.py

@@ -4,29 +4,87 @@ TODO:
  - dynamic registration
  - dynamic switching (skip docker if not running, skip online if not online, ...)
 """
+import dataclasses as dc
 import typing as ta
 
 import pytest
 
 from .... import check
 from .... import collections as col
-from .... import lang
 from ....docker import all as docker
 from ._registry import register
 
 
-Configable = pytest.FixtureRequest | pytest.Config
+Configable: ta.TypeAlias = pytest.FixtureRequest | pytest.Config
 
 
-SWITCHES: ta.Mapping[str, bool | ta.Callable[[], bool]] = {
-    'docker': docker.has_cli,
-    'docker-guest': docker.is_likely_in_docker,
-    'online': True,
-    'integration': True,
-    'slow': False,
-}
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class Switch:
+    name: str
+    _default_enabled: bool | ta.Callable[[], bool]
+
+    _: dc.KW_ONLY
+
+    add_marks: ta.Sequence[ta.Any] | None = None
+
+    def default_enabled(self) -> bool:
+        if isinstance(e := self._default_enabled, bool):
+            return e
+        elif callable(e):
+            return check.isinstance(e(), bool)
+        else:
+            raise TypeError(e)
+
+    @property
+    def attr(self) -> str:
+        return self.name.replace('-', '_')
+
+
+SWITCHES: ta.Sequence[Switch] = [
+    Switch(
+        'name',
+        docker.has_cli,
+    ),
+
+    Switch(
+        'docker-guest',
+        docker.is_likely_in_docker,
+    ),
+
+    Switch(
+        'online',
+        True,
+    ),
 
-SWITCH_ATTRS = {k.replace('-', '_'): k for k in SWITCHES}
+    Switch(
+        'integration',
+        True,
+    ),
+
+    Switch(
+        'high-mem',
+        True,
+        add_marks=[
+            # https://pytest-xdist.readthedocs.io/en/latest/distribution.html
+            pytest.mark.xdist_group('high-mem'),
+        ],
+    ),
+
+    Switch(
+        'slow',
+        False,
+    ),
+]
+
+
+SWITCHES_BY_NAME: ta.Mapping[str, Switch] = col.make_map_by(lambda sw: sw.name, SWITCHES, strict=True)
+SWITCHES_BY_ATTR: ta.Mapping[str, Switch] = col.make_map_by(lambda sw: sw.attr, SWITCHES, strict=True)
+
+
+##
 
 
 SwitchState: ta.TypeAlias = bool | ta.Literal['only']
@@ -49,7 +107,7 @@ def _get_obj_config(obj: Configable) -> pytest.Config:
 
 def is_disabled(obj: Configable | None, name: str) -> bool:
     check.isinstance(name, str)
-    check.in_(name, SWITCHES)
+    check.in_(name, SWITCHES_BY_NAME)
     return obj is not None and _get_obj_config(obj).getoption(f'--no-{name}')
 
 
@@ -58,17 +116,17 @@ def skip_if_disabled(obj: Configable | None, name: str) -> None:
         pytest.skip(f'{name} disabled')
 
 
-def get_specified_switches(obj: Configable) -> ta.Mapping[str, SwitchState]:
-    ret: dict[str, SwitchState] = {}
+def get_specified_switches(obj: Configable) -> dict[Switch, SwitchState]:
+    ret: dict[Switch, SwitchState] = {}
     for sw in SWITCHES:
         sts = {
             st
             for st, pfx in SWITCH_STATE_OPT_PREFIXES.items()
-            if _get_obj_config(obj).getoption(pfx + sw)
+            if _get_obj_config(obj).getoption(pfx + sw.name)
         }
         if sts:
             if len(sts) > 1:
-                raise Exception(f'Multiple switches specified for {sw}')
+                raise Exception(f'Multiple switches specified for {sw.name}')
             ret[sw] = check.single(sts)
     return ret
 
@@ -76,49 +134,50 @@ def get_specified_switches(obj: Configable) -> ta.Mapping[str, SwitchState]:
 @register
 class SwitchesPlugin:
     def pytest_configure(self, config):
-        for sw in SWITCH_ATTRS:
-            config.addinivalue_line('markers', f'{sw}: mark test as {sw}')
-            config.addinivalue_line('markers', f'not_{sw}: mark test as not {sw}')
+        for sw in SWITCHES:
+            config.addinivalue_line('markers', f'{sw.attr}: mark test as {sw.attr}')
+            config.addinivalue_line('markers', f'not_{sw.attr}: mark test as not {sw.attr}')
 
     def pytest_addoption(self, parser):
         for sw in SWITCHES:
-            parser.addoption(f'--no-{sw}', action='store_true', default=False, help=f'disable {sw} tests')
-            parser.addoption(f'--{sw}', action='store_true', default=False, help=f'enables {sw} tests')
-            parser.addoption(f'--only-{sw}', action='store_true', default=False, help=f'enables only {sw} tests')
-
-    @lang.cached_function
-    def get_switches(self) -> ta.Mapping[str, SwitchState]:
-        return {
-            k: v() if callable(v) else v
-            for k, v in SWITCHES.items()
-        }
+            parser.addoption(f'--no-{sw.name}', action='store_true', default=False, help=f'disable {sw.name} tests')
+            parser.addoption(f'--{sw.name}', action='store_true', default=False, help=f'enables {sw.name} tests')
+            parser.addoption(f'--only-{sw.name}', action='store_true', default=False, help=f'enables only {sw.name} tests')  # noqa
 
     def pytest_collection_modifyitems(self, config, items):
-        sts = {
-            **self.get_switches(),
+        switch_states: dict[Switch, SwitchState] = {
+            **{
+                sw: sw.default_enabled()
+                for sw in SWITCHES
+            },
             **get_specified_switches(config),
         }
 
-        stx = col.multi_map(map(reversed, sts.items()))  # type: ignore
-        ts, fs, onlys = (stx.get(k, ()) for k in (True, False, 'only'))
+        inv_switch_states: dict[SwitchState, list[Switch]] = col.multi_map((st, sw) for sw, st in switch_states.items())
+        true_switches = frozenset(inv_switch_states.get(True, ()))
+        false_switches = frozenset(inv_switch_states.get(False, ()))
+        only_switches = frozenset(inv_switch_states.get('only', ()))
 
         def process(item):
-            sws = {sw for swa, sw in SWITCH_ATTRS.items() if swa in item.keywords}
-            nsws = {sw for swa, sw in SWITCH_ATTRS.items() if ('not_' + swa) in item.keywords}
+            item_switches = {sw for sw in SWITCHES if sw.attr in item.keywords}
+            item_not_switches = {sw for sw in SWITCHES if ('not_' + sw.attr) in item.keywords}
+
+            for sw in item_switches:
+                for mk in sw.add_marks or []:
+                    item.add_marker(mk)
 
-            if onlys:
-                if not any(sw in onlys for sw in sws):
-                    item.add_marker(pytest.mark.skip(reason=f'skipping switches {sws}'))
+            if only_switches:
+                if not any(sw in only_switches for sw in item_switches):
+                    item.add_marker(pytest.mark.skip(reason=f'skipping switches {item_switches}'))
                     return
 
-            else:
-                for sw in sws:
-                    if sw in fs:
-                        item.add_marker(pytest.mark.skip(reason=f'skipping switches {sw}'))
+            for sw in item_switches:
+                if sw in false_switches:
+                    item.add_marker(pytest.mark.skip(reason=f'skipping switches {sw}'))
 
-                for nsw in nsws:
-                    if nsw in ts:
-                        item.add_marker(pytest.mark.skip(reason=f'skipping switches {nsw}'))
+            for sw in item_not_switches:
+                if sw in true_switches:
+                    item.add_marker(pytest.mark.skip(reason=f'skipping switches {sw}'))
 
         for item in items:
             process(item)

{omlish-0.0.0.dev315.dist-info → omlish-0.0.0.dev317.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev315
+Version: 0.0.0.dev317
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause