omdev 0.0.0.dev315__tar.gz → 0.0.0.dev317__tar.gz

{omdev-0.0.0.dev315/omdev.egg-info → omdev-0.0.0.dev317}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev315
+Version: 0.0.0.dev317
 Summary: omdev
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev315
+Requires-Dist: omlish==0.0.0.dev317
 Provides-Extra: all
 Requires-Dist: black~=25.1; extra == "all"
 Requires-Dist: pycparser~=2.22; extra == "all"

{omdev-0.0.0.dev315 → omdev-0.0.0.dev317}/omdev/scripts/ci.py

@@ -41,6 +41,7 @@ import gzip
 import hashlib
 import heapq
 import html
+import http
 import http.client
 import http.server
 import inspect
@@ -98,6 +99,9 @@ CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
 CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
 CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
+# ../../omlish/lite/maybes.py
+U = ta.TypeVar('U')
+
 # ../../omlish/lite/timeouts.py
 TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.DEFAULT'], ta.Iterable['TimeoutLike'], float, None]  # ta.TypeAlias
 
@@ -122,7 +126,6 @@ ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
 AsyncExitStackedT = ta.TypeVar('AsyncExitStackedT', bound='AsyncExitStacked')
 
 # ../../omlish/lite/inject.py
-U = ta.TypeVar('U')
 InjectorKeyCls = ta.Union[type, ta.NewType]
 InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
 InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
@@ -1145,7 +1148,13 @@ log = logging.getLogger(__name__)
 ##
 
 
+@functools.total_ordering
 class Maybe(ta.Generic[T]):
+    class ValueNotPresentError(BaseException):
+        pass
+
+    #
+
     @property
     @abc.abstractmethod
     def present(self) -> bool:
@@ -1155,9 +1164,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']
 
@@ -1166,36 +1268,81 @@ class Maybe(ta.Generic[T]):
         return Maybe._empty
 
 
-class _Maybe(Maybe[T], tuple):
-    __slots__ = ()
+##
 
-    def __init_subclass__(cls, **kwargs):
-        raise TypeError
+
+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
+
+
+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
+        )
 
-@functools.singledispatch
-def as_maybe(obj: ta.Any) -> Maybe:
-    raise TypeError(obj)
 
+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()'
 
-@as_maybe.register
-def _(obj: Maybe) -> Maybe:
-    return obj
+    def __hash__(self) -> int:
+        return hash(_EmptyMaybe)
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__
+
+
+Maybe._empty = _EmptyMaybe()  # noqa
 
 
 ########################################
@@ -1587,9 +1734,16 @@ class PredicateTimeout(Timeout):
 # ../../../omlish/logs/filters.py
 
 
+##
+
+
 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
 
 
@@ -1597,6 +1751,9 @@ class TidLogFilter(logging.Filter):
 # ../../../omlish/logs/proxy.py
 
 
+##
+
+
 class ProxyLogFilterer(logging.Filterer):
     def __init__(self, underlying: logging.Filterer) -> None:  # noqa
         self._underlying = underlying
@@ -5114,6 +5271,9 @@ TODO:
 """
 
 
+##
+
+
 class JsonLogFormatter(logging.Formatter):
     KEYS: ta.Mapping[str, bool] = {
         'name': False,

{omdev-0.0.0.dev315 → omdev-0.0.0.dev317}/omdev/scripts/interp.py

@@ -71,6 +71,9 @@ CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
 CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
 CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
+# ../../omlish/lite/maybes.py
+U = ta.TypeVar('U')
+
 # ../../omlish/lite/timeouts.py
 TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.DEFAULT'], ta.Iterable['TimeoutLike'], float, None]  # ta.TypeAlias
 
@@ -86,7 +89,6 @@ ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
 # ../../omlish/lite/inject.py
-U = ta.TypeVar('U')
 InjectorKeyCls = ta.Union[type, ta.NewType]
 InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
 InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
@@ -1088,7 +1090,13 @@ json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON
 ##
 
 
+@functools.total_ordering
 class Maybe(ta.Generic[T]):
+    class ValueNotPresentError(BaseException):
+        pass
+
+    #
+
     @property
     @abc.abstractmethod
     def present(self) -> bool:
@@ -1098,9 +1106,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']
 
@@ -1109,36 +1210,81 @@ class Maybe(ta.Generic[T]):
         return Maybe._empty
 
 
-class _Maybe(Maybe[T], tuple):
-    __slots__ = ()
+##
 
-    def __init_subclass__(cls, **kwargs):
-        raise TypeError
+
+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
+
+
+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
+
+    #
 
+    def __repr__(self) -> str:
+        return f'just({self._v!r})'
 
-Maybe._empty = tuple.__new__(_Maybe, ())  # noqa
+    _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
+        )
 
 
-@functools.singledispatch
-def as_maybe(obj: ta.Any) -> Maybe:
-    raise TypeError(obj)
+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)
 
-@as_maybe.register
-def _(obj: Maybe) -> Maybe:
-    return obj
+    def __eq__(self, other):
+        return self.__class__ is other.__class__
+
+
+Maybe._empty = _EmptyMaybe()  # noqa
 
 
 ########################################
@@ -1530,9 +1676,16 @@ class PredicateTimeout(Timeout):
 # ../../../omlish/logs/filters.py
 
 
+##
+
+
 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
 
 
@@ -1540,6 +1693,9 @@ class TidLogFilter(logging.Filter):
 # ../../../omlish/logs/proxy.py
 
 
+##
+
+
 class ProxyLogFilterer(logging.Filterer):
     def __init__(self, underlying: logging.Filterer) -> None:  # noqa
         self._underlying = underlying
@@ -3579,6 +3735,9 @@ TODO:
 """
 
 
+##
+
+
 class JsonLogFormatter(logging.Formatter):
     KEYS: ta.Mapping[str, bool] = {
         'name': False,