omlish 0.0.0.dev338__py3-none-any.whl → 0.0.0.dev340__py3-none-any.whl

omlish/graphs/dot/items.py

@@ -12,6 +12,9 @@ from ... import dataclasses as dc
 from ... import lang
 
 
+##
+
+
 class Item(dc.Frozen, lang.Abstract, lang.Sealed):
     pass
 

omlish/graphs/dot/make.py

@@ -9,6 +9,9 @@ from .items import Node
 T = ta.TypeVar('T')
 
 
+##
+
+
 def make_simple(graph: ta.Mapping[T, ta.Iterable[T]]) -> Graph:
     return Graph([
         *[Node(n) for n in {*graph, *lang.flatten(graph.values())}],

omlish/graphs/dot/rendering.py

@@ -20,6 +20,9 @@ from .items import Table
 from .items import Text
 
 
+##
+
+
 class Renderer:
     def __init__(self, out: ta.TextIO) -> None:
         super().__init__()

omlish/graphs/dot/utils.py

@@ -2,6 +2,9 @@ import html
 import typing as ta
 
 
+##
+
+
 def escape(s: str) -> str:
     return html.escape(s).replace('@', '@')
 

omlish/graphs/trees.py

@@ -10,13 +10,14 @@ from .. import cached
 from .. import check
 from .. import collections as col
 from .. import lang
-from ..algorithm import all as alg
+from ..algorithm.toposort import mut_toposort
 
 
 T = ta.TypeVar('T')
 NodeT = ta.TypeVar('NodeT')
-NodeWalker = ta.Callable[[NodeT], ta.Iterable[NodeT]]
-NodeGenerator = ta.Generator[NodeT, None, None]
+
+NodeWalker: ta.TypeAlias = ta.Callable[[NodeT], ta.Iterable[NodeT]]
+NodeGenerator: ta.TypeAlias = ta.Generator[NodeT, None, None]
 
 
 ##
@@ -200,7 +201,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}
-        ts = list(alg.mut_toposort(tsd))
+        ts = list(mut_toposort(tsd))
         root = d(check.single(ts[0]))
 
         return cls(

omlish/lang/__init__.py

@@ -61,12 +61,21 @@ from .classes.abstract import (  # noqa
     unabstract_class,
 )
 
+from .classes.bindable import (  # noqa
+    BindableClass,
+)
+
 from .classes.namespaces import (  # noqa
     GenericNamespaceMeta,
     Namespace,
     NamespaceMeta,
 )
 
+from .classes.protocols import (  # noqa
+    ProtocolForbiddenAsBaseClass,
+    ProtocolForbiddenAsBaseClassTypeError,
+)
+
 from .classes.restrict import (  # noqa
     AnySensitive,
     Final,

omlish/lang/classes/bindable.py

@@ -0,0 +1,43 @@
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class _ClassOrInstanceMethod:
+    def __init__(self, func):
+        super().__init__()
+
+        self.__func__ = func
+
+    def __get__(self, instance, owner=None):
+        return self.__func__.__get__(instance if instance is not None else owner)
+
+
+class BindableClass(ta.Generic[T]):
+    # FIXME: apparently can't have TypeVars in ClassVars, but could stick in a @classmethod (which gets transformed)...
+    _bound: ta.ClassVar[type[T] | None] = None  # type: ignore[misc]
+
+    def __init__(self, *, _bound):
+        super().__init__()
+
+        setattr(self, '_bound', _bound)
+
+    def __class_getitem__(cls, *args, **kwargs):
+        # FIXME: this could handle __mro_items__ to be subclassable, but it's not currently really intended to be
+        #   subclassed
+        if cls is BindableClass:
+            return super().__class_getitem__(*args, **kwargs)  # type: ignore[misc]
+
+        [bind_cls] = args
+        return cls(_bound=bind_cls)
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        for k, v in cls.__dict__.items():
+            if isinstance(v, classmethod):
+                setattr(cls, k, _ClassOrInstanceMethod(v.__func__))

omlish/lang/classes/protocols.py

@@ -0,0 +1,26 @@
+import typing as ta
+
+
+##
+
+
+class ProtocolForbiddenAsBaseClass(ta.Protocol):
+    pass
+
+
+class ProtocolForbiddenAsBaseClassTypeError(TypeError):
+    pass
+
+
+def _ProtocolForbiddenAsBaseClass__init_subclass__(cls: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    if ta.Protocol not in cls.__mro__:
+        raise TypeError(f'Class {cls} must be a Protocol')
+
+    super(ProtocolForbiddenAsBaseClass, cls).__init_subclass__(**kwargs)  # noqa
+
+    # TODO: ta.Protocol not in cls.__bases__ ?
+    if not cls.__dict__['_is_protocol']:
+        raise ProtocolForbiddenAsBaseClassTypeError(cls)
+
+
+setattr(ProtocolForbiddenAsBaseClass, '__init_subclass__', classmethod(_ProtocolForbiddenAsBaseClass__init_subclass__))

omlish/math/__init__.py

@@ -35,11 +35,11 @@ from .fixed import (  # noqa
     CheckedInt64,
     CheckedInt128,
 
-    CheckedUInt8,
-    CheckedUInt16,
-    CheckedUInt32,
-    CheckedUInt64,
-    CheckedUInt128,
+    CheckedUint8,
+    CheckedUint16,
+    CheckedUint32,
+    CheckedUint64,
+    CheckedUint128,
 
     ClampedInt8,
     ClampedInt16,
@@ -47,11 +47,11 @@ from .fixed import (  # noqa
     ClampedInt64,
     ClampedInt128,
 
-    ClampedUInt8,
-    ClampedUInt16,
-    ClampedUInt32,
-    ClampedUInt64,
-    ClampedUInt128,
+    ClampedUint8,
+    ClampedUint16,
+    ClampedUint32,
+    ClampedUint64,
+    ClampedUint128,
 
     WrappedInt8,
     WrappedInt16,
@@ -59,11 +59,11 @@ from .fixed import (  # noqa
     WrappedInt64,
     WrappedInt128,
 
-    WrappedUInt8,
-    WrappedUInt16,
-    WrappedUInt32,
-    WrappedUInt64,
-    WrappedUInt128,
+    WrappedUint8,
+    WrappedUint16,
+    WrappedUint32,
+    WrappedUint64,
+    WrappedUint128,
 )
 
 from .floats import (  # noqa

omlish/math/fixed.py

@@ -183,6 +183,16 @@ class FixedWidthInt(int, lang.Abstract):
         locals()[_proxy_name] = _gen_tuple_proxy_method(_proxy_name)
     del _proxy_name
 
+    #
+
+    def __invert__(self) -> ta.Self:
+        if not self.SIGNED:
+            return self.__class__(~int(self) & self.MASK)
+        else:
+            return self.__class__(super().__invert__())
+
+    #
+
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({int(self)})'
 
@@ -278,23 +288,23 @@ class CheckedInt128(CheckedInt, SignedInt, AnyInt128):
 #
 
 
-class CheckedUInt8(CheckedInt, UnsignedInt, AnyInt8):
+class CheckedUint8(CheckedInt, UnsignedInt, AnyInt8):
     pass
 
 
-class CheckedUInt16(CheckedInt, UnsignedInt, AnyInt16):
+class CheckedUint16(CheckedInt, UnsignedInt, AnyInt16):
     pass
 
 
-class CheckedUInt32(CheckedInt, UnsignedInt, AnyInt32):
+class CheckedUint32(CheckedInt, UnsignedInt, AnyInt32):
     pass
 
 
-class CheckedUInt64(CheckedInt, UnsignedInt, AnyInt64):
+class CheckedUint64(CheckedInt, UnsignedInt, AnyInt64):
     pass
 
 
-class CheckedUInt128(CheckedInt, UnsignedInt, AnyInt128):
+class CheckedUint128(CheckedInt, UnsignedInt, AnyInt128):
     pass
 
 
@@ -324,23 +334,23 @@ class ClampedInt128(ClampedInt, SignedInt, AnyInt128):
 #
 
 
-class ClampedUInt8(ClampedInt, UnsignedInt, AnyInt8):
+class ClampedUint8(ClampedInt, UnsignedInt, AnyInt8):
     pass
 
 
-class ClampedUInt16(ClampedInt, UnsignedInt, AnyInt16):
+class ClampedUint16(ClampedInt, UnsignedInt, AnyInt16):
     pass
 
 
-class ClampedUInt32(ClampedInt, UnsignedInt, AnyInt32):
+class ClampedUint32(ClampedInt, UnsignedInt, AnyInt32):
     pass
 
 
-class ClampedUInt64(ClampedInt, UnsignedInt, AnyInt64):
+class ClampedUint64(ClampedInt, UnsignedInt, AnyInt64):
     pass
 
 
-class ClampedUInt128(ClampedInt, UnsignedInt, AnyInt128):
+class ClampedUint128(ClampedInt, UnsignedInt, AnyInt128):
     pass
 
 
@@ -370,21 +380,21 @@ class WrappedInt128(WrappedInt, SignedInt, AnyInt128):
 #
 
 
-class WrappedUInt8(WrappedInt, UnsignedInt, AnyInt8):
+class WrappedUint8(WrappedInt, UnsignedInt, AnyInt8):
     pass
 
 
-class WrappedUInt16(WrappedInt, UnsignedInt, AnyInt16):
+class WrappedUint16(WrappedInt, UnsignedInt, AnyInt16):
     pass
 
 
-class WrappedUInt32(WrappedInt, UnsignedInt, AnyInt32):
+class WrappedUint32(WrappedInt, UnsignedInt, AnyInt32):
     pass
 
 
-class WrappedUInt64(WrappedInt, UnsignedInt, AnyInt64):
+class WrappedUint64(WrappedInt, UnsignedInt, AnyInt64):
     pass
 
 
-class WrappedUInt128(WrappedInt, UnsignedInt, AnyInt128):
+class WrappedUint128(WrappedInt, UnsignedInt, AnyInt128):
     pass

omlish/os/forkhooks.py

@@ -36,9 +36,9 @@ class _ForkHookManager:
 
     #
 
-    _hooks_by_key: ta.ClassVar[ta.Dict[str, Hook]] = {}
+    _hooks_by_key: ta.ClassVar[ta.Dict[ta.Any, Hook]] = {}
 
-    _hook_keys: ta.ClassVar[ta.FrozenSet[str]] = frozenset()
+    _hook_keys: ta.ClassVar[ta.FrozenSet[ta.Any]] = frozenset()
     _priority_ordered_hooks: ta.ClassVar[ta.List[Hook]] = []
 
     @classmethod
@@ -191,7 +191,7 @@ class ForkHook(abc.ABC):  # noqa
 ##
 
 
-class _ForkDepthTracker(ForkHook):
+class ForkDepthTracker(ForkHook):
     _hook_priority = -1000
 
     _fork_depth: ta.ClassVar[int] = 0
@@ -208,7 +208,7 @@ class _ForkDepthTracker(ForkHook):
 
 
 def get_fork_depth() -> int:
-    return _ForkDepthTracker.get_fork_depth()
+    return ForkDepthTracker.get_fork_depth()
 
 
 ##

omlish/testing/pytest/plugins/switches/plugin.py

@@ -3,6 +3,7 @@ TODO:
  - inheritance
  - dynamic registration
  - dynamic switching (skip docker if not running, skip online if not online, ...)
+ - probably make IF_SINGLE understand parametErization
 """
 import dataclasses as dc
 import typing as ta
@@ -121,6 +122,7 @@ class SwitchesPlugin:
     def pytest_sessionstart(self, session):
         session.stash[self._states_key] = self._States(session)
 
+    @pytest.hookimpl(tryfirst=True)
     def pytest_collection_modifyitems(self, config, items):
         def process_item(item):
             state: SwitchesPlugin._States = item.session.stash[self._states_key]

omlish/testing/pytest/skip.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - if_not_single? switches does this
+"""
 import shutil
 import sys
 import sysconfig
@@ -11,8 +15,9 @@ from ... import lang
 ##
 
 
-def if_cant_import(module: str, *args, **kwargs):
-    return pytest.mark.skipif(not lang.can_import(module, *args, **kwargs), reason=f'requires import {module}')
+def if_cant_import(*modules: str, **kwargs):
+    missing = [m for m in modules if not lang.can_import(m, **kwargs)]
+    return pytest.mark.skipif(bool(missing), reason=f'requires import {", ".join(missing)}')
 
 
 def if_not_on_path(exe: str):
@@ -27,11 +32,5 @@ def if_not_platform(*platforms: str):
     return pytest.mark.skipif(sys.platform not in platforms, reason=f'requires platform in {platforms}')
 
 
-def if_not_single():
-    # FIXME
-    # [resolve_collection_argument(a) for a in session.config.args]
-    raise NotImplementedError
-
-
 def if_nogil():
     return pytest.mark.skipif(sysconfig.get_config_var('Py_GIL_DISABLED'), reason='requires gil build')

omlish/typedvalues/__init__.py

@@ -22,6 +22,10 @@ from .holder import (  # noqa
     TypedValueHolder,
 )
 
+from .of_ import (  # noqa
+    of,
+)
+
 from .reflect import (  # noqa
     reflect_typed_values_impls,
 )

omlish/typedvalues/accessor.py

@@ -27,7 +27,11 @@ class _NOT_SET(lang.Marker):  # noqa
     pass
 
 
-class TypedValuesAccessor(lang.Abstract, ta.Sequence[TypedValueT0]):
+class TypedValuesAccessor(
+    lang.Abstract,
+    ta.Sequence[TypedValueT0],
+    ta.Generic[TypedValueT0],
+):
     def __iter__(self):
         raise TypeError(
             'TypedValuesAccessor does not implement __iter__ - it is reserved for implementation by subclasses.',

omlish/typedvalues/collection.py

@@ -10,6 +10,7 @@ from .values import UniqueTypedValue
 
 
 TypedValueT = ta.TypeVar('TypedValueT', bound='TypedValue')
+TypedValueU = ta.TypeVar('TypedValueU', bound='TypedValue')
 
 UniqueTypedValueT = ta.TypeVar('UniqueTypedValueT', bound='UniqueTypedValue')
 

omlish/typedvalues/of_.py

@@ -0,0 +1,51 @@
+import typing as ta
+
+from .. import lang
+from .collection import TypedValues
+from .consumer import TypedValuesConsumer
+from .values import TypedValue
+
+
+TypedValueT = ta.TypeVar('TypedValueT', bound=TypedValue)
+
+
+##
+
+
+class _TypedValuesOf(lang.BindableClass[TypedValueT]):  # noqa
+    @classmethod
+    def collect(
+            cls,
+            *tvs: TypedValueT,
+            override: bool = False,
+            check_type: bool | type | tuple[type, ...] | None = None,
+    ) -> TypedValues[TypedValueT]:  # noqa
+        if isinstance(check_type, bool):
+            if check_type:
+                if cls._bound is None:
+                    raise TypeError('TypedValues.of unbound, cannot use check_type=True')
+                check_type = cls._bound
+            else:
+                check_type = None
+
+        return TypedValues(
+            *tvs,
+            override=override,
+            check_type=check_type,
+        )
+
+    @classmethod
+    def consume(
+            cls,
+            *tvs: TypedValueT,
+            override: bool = False,
+            check_type: bool | type | tuple[type, ...] | None = None,
+    ) -> TypedValuesConsumer[TypedValueT]:
+        return cls.collect(
+            *tvs,
+            override=override,
+            check_type=check_type,
+        ).consume()
+
+
+of = _TypedValuesOf

{omlish-0.0.0.dev338.dist-info → omlish-0.0.0.dev340.dist-info}/METADATA

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