omlish 0.0.0.dev271__py3-none-any.whl → 0.0.0.dev272__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev271'
-__revision__ = 'fc242f5a994ee5dd88268a5720ed88792d17c61f'
+__version__ = '0.0.0.dev272'
+__revision__ = '77ed49b2a8b3f746064a52c4b81e1c02dba03a40'
 
 
 #

omlish/typedvalues/__init__.py

@@ -0,0 +1,25 @@
+from .accessor import (  # noqa
+    TypedValuesAccessor,
+)
+
+from .collection import (  # noqa
+    DuplicateUniqueTypedValueError,
+
+    TypedValues,
+)
+
+from .generic import (  # noqa
+    TypedValueGeneric,
+)
+
+from .holder import (  # noqa
+    TypedValueHolder,
+)
+
+from .values import (  # noqa
+    TypedValue,
+
+    UniqueTypedValue,
+
+    ScalarTypedValue,
+)

omlish/typedvalues/accessor.py

@@ -0,0 +1,113 @@
+"""
+TODO:
+ - Accessor inputs/outputs should *ideally* be subtype of class generic param
+  - but can't make a typevar with a bound of another typevar
+"""
+import abc
+import typing as ta
+
+from .. import lang
+from .values import TypedValue  # noqa
+from .values import UniqueTypedValue  # noqa
+
+
+T = ta.TypeVar('T')
+
+TypedValueT = ta.TypeVar('TypedValueT', bound='TypedValue')
+TypedValueU = ta.TypeVar('TypedValueU', bound='TypedValue')
+
+UniqueTypedValueU = ta.TypeVar('UniqueTypedValueU', bound='UniqueTypedValue')
+
+
+##
+
+
+class TypedValuesAccessor(lang.Abstract, ta.Generic[TypedValueT]):
+    @ta.final
+    def __contains__(self, cls: type[TypedValueU]) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _typed_value_contains(self, cls):
+        raise NotImplementedError
+
+    #
+
+    @ta.overload
+    def __getitem__(self, idx: int) -> TypedValueT:
+        ...
+
+    @ta.overload
+    def __getitem__(self, cls: type[UniqueTypedValueU]) -> UniqueTypedValueU:  # type: ignore[overload-overlap]
+        ...
+
+    @ta.overload
+    def __getitem__(self, cls: type[TypedValueU]) -> ta.Sequence[TypedValueU]:
+        ...
+
+    @ta.final
+    def __getitem__(self, key):
+        return self._typed_value_getitem(key)
+
+    @abc.abstractmethod
+    def _typed_value_getitem(self, key):
+        raise NotImplementedError
+
+    #
+
+    @ta.overload
+    def get(
+            self,
+            tv: UniqueTypedValueU,
+    ) -> UniqueTypedValueU:
+        ...
+
+    @ta.overload
+    def get(
+            self,
+            cls: type[UniqueTypedValueU],
+            /,
+            default: UniqueTypedValueU,
+    ) -> UniqueTypedValueU:
+        ...
+
+    @ta.overload
+    def get(  # type: ignore[overload-overlap]
+            self,
+            cls: type[UniqueTypedValueU],
+            /,
+            default: None = None,
+    ) -> UniqueTypedValueU | None:
+        ...
+
+    @ta.overload
+    def get(
+            self,
+            cls: type[TypedValueU],
+            /,
+            default: ta.Iterable[TypedValueU] | None = None,
+    ) -> ta.Sequence[TypedValueU]:
+        ...
+
+    @ta.final
+    def get(self, key, /, default=None):
+        if not isinstance(key, type):
+            if default is not None:
+                raise RuntimeError('Must not provide both an instance key and a default')
+            default = key
+            key = type(default)
+        return self._typed_value_get(key, default)
+
+    @abc.abstractmethod
+    def _typed_value_get(self, key, /, default=None):
+        raise NotImplementedError
+
+    #
+
+    @ta.final
+    def get_any(self, cls: type[T]) -> ta.Sequence[T]:
+        return self._typed_value_get_any(cls)
+
+    @abc.abstractmethod
+    def _typed_value_get_any(self, cls):
+        raise NotImplementedError

omlish/typedvalues/collection.py

@@ -0,0 +1,124 @@
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from .accessor import TypedValuesAccessor
+from .values import TypedValue
+from .values import UniqueTypedValue
+
+
+TypedValueT = ta.TypeVar('TypedValueT', bound='TypedValue')
+
+UniqueTypedValueT = ta.TypeVar('UniqueTypedValueT', bound='UniqueTypedValue')
+
+
+##
+
+
+@dc.dataclass()
+class DuplicateUniqueTypedValueError(Exception, ta.Generic[UniqueTypedValueT]):
+    cls: type[UniqueTypedValueT]
+    new: UniqueTypedValueT
+    old: UniqueTypedValueT
+
+
+class TypedValues(
+    TypedValuesAccessor[TypedValueT],
+    lang.Final,
+    ta.Generic[TypedValueT],
+):
+    def __init__(self, *tvs: TypedValueT, override: bool = False) -> None:
+        super().__init__()
+
+        tmp: list = []
+        udct: dict = {}
+        for tv in tvs:
+            if isinstance(tv, UniqueTypedValue):
+                uoc = tv._unique_typed_value_cls  # noqa
+                if not override:
+                    try:
+                        exu = udct[uoc]
+                    except KeyError:
+                        pass
+                    else:
+                        raise DuplicateUniqueTypedValueError(uoc, tv, check.single(exu))
+                ulst = udct.setdefault(uoc, [])
+                ulst.append(tv)
+                tmp.append((tv, len(ulst)))
+            elif isinstance(tv, TypedValue):
+                tmp.append(tv)
+            else:
+                raise TypeError(tv)
+
+        lst: list = []
+        dct: dict = {}
+        for tv in tmp:
+            if isinstance(tv, tuple):
+                uo, idx = tv  # type: ignore
+                ulst = udct[uo._unique_typed_value_cls]  # noqa
+                if idx == len(ulst):
+                    lst.append(uo)
+                    dct[uo._unique_typed_value_cls] = uo  # noqa
+                    dct[type(uo)] = uo
+            else:
+                lst.append(tv)
+                dct.setdefault(type(tv), []).append(tv)
+
+        self._lst = lst
+        self._dct = dct
+
+        self._any_dct: dict[type, ta.Sequence[ta.Any]] = {}
+
+    def without(self, *tys: type) -> ta.Iterator[TypedValueT]:
+        for o in self._lst:
+            if not isinstance(o, tys):
+                yield o
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join(map(repr, self._lst))})'
+
+    #
+
+    def __iter__(self) -> ta.Iterator[TypedValueT]:
+        return iter(self._lst)
+
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    def __bool__(self) -> bool:
+        return bool(self._lst)
+
+    #
+
+    def _typed_value_contains(self, cls):
+        return cls in self._dct
+
+    def _typed_value_getitem(self, key):
+        if isinstance(key, int):
+            return self._lst[key]
+        elif isinstance(key, type):
+            return self._dct[check.issubclass(key, TypedValue)]
+        else:
+            raise TypeError(key)
+
+    def _typed_value_get(self, key, /, default=None):
+        check.issubclass(key, TypedValue)
+        try:
+            return self._dct[key]
+        except KeyError:
+            if issubclass(key, UniqueTypedValue):
+                return default
+            elif default is not None:
+                return list(default)
+            else:
+                return []
+
+    def _typed_value_get_any(self, cls):
+        try:
+            return self._any_dct[cls]
+        except KeyError:
+            pass
+        ret = [tv for tv in self if isinstance(tv, cls)]
+        self._any_dct[cls] = ret
+        return ret

omlish/typedvalues/generic.py

@@ -0,0 +1,31 @@
+import typing as ta
+
+from .. import check
+from .. import lang
+from .. import reflect as rfl
+from .values import TypedValue  # noqa
+
+
+TypedValueT = ta.TypeVar('TypedValueT', bound='TypedValue')
+
+
+##
+
+
+class TypedValueGeneric(lang.Abstract, ta.Generic[TypedValueT]):
+    _typed_value_type: ta.ClassVar[rfl.Type]
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if '_typed_value_type' in cls.__dict__:
+            return
+
+        g_mro = rfl.ALIAS_UPDATING_GENERIC_SUBSTITUTION.generic_mro(cls)
+        g_tvg = check.single(
+            gb
+            for gb in g_mro
+            if isinstance(gb, rfl.Generic) and gb.cls is TypedValueGeneric
+        )
+        tvt = check.single(g_tvg.args)
+        cls._typed_value_type = tvt

omlish/typedvalues/holder.py

@@ -0,0 +1,60 @@
+import abc
+import typing as ta
+
+from .. import check
+from .. import lang
+from .accessor import TypedValuesAccessor
+from .collection import TypedValues
+from .generic import TypedValueGeneric
+from .values import TypedValue
+from .values import UniqueTypedValue
+
+
+TypedValueT = ta.TypeVar('TypedValueT', bound='TypedValue')
+
+
+##
+
+
+class TypedValueHolder(
+    TypedValuesAccessor[TypedValueT],
+    TypedValueGeneric[TypedValueT],
+    lang.Abstract,
+):
+    @property
+    @abc.abstractmethod
+    def _typed_values(self) -> TypedValues[TypedValueT] | None:
+        raise NotImplementedError
+
+    #
+
+    def _typed_value_contains(self, cls):
+        if (tvs := self._typed_values) is not None:
+            return cls in tvs
+        return False
+
+    def _typed_value_getitem(self, key):
+        if (tvs := self._typed_values) is not None:
+            return tvs[key]
+        if isinstance(key, int):
+            raise IndexError(key)
+        elif isinstance(key, type):
+            raise KeyError(key)
+        else:
+            raise TypeError(key)
+
+    def _typed_value_get(self, key, /, default=None):
+        if (tvs := self._typed_values) is not None:
+            return tvs.get(key, default)
+        check.issubclass(key, TypedValue)
+        if issubclass(key, UniqueTypedValue):
+            return default
+        elif default is not None:
+            return list(default)
+        else:
+            return []
+
+    def _typed_value_get_any(self, cls):
+        if (tvs := self._typed_values) is not None:
+            return tvs.get_any(cls)
+        return []

omlish/typedvalues/values.py

@@ -0,0 +1,38 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class TypedValue(lang.Abstract):
+    pass
+
+
+class UniqueTypedValue(TypedValue, lang.Abstract):
+    _unique_typed_value_cls: ta.ClassVar[type[TypedValue]]
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if UniqueTypedValue in cls.__bases__:
+            try:
+                cls._unique_typed_value_cls  # noqa
+            except AttributeError:
+                cls._unique_typed_value_cls = cls
+            else:
+                raise TypeError(f'Class already has _unique_typed_value_cls: {cls}')
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(generic_init=True)
+class ScalarTypedValue(TypedValue, lang.Abstract, ta.Generic[T]):
+    v: T
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.v!r})'

{omlish-0.0.0.dev271.dist-info → omlish-0.0.0.dev272.dist-info}/METADATA

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

{omlish-0.0.0.dev271.dist-info → omlish-0.0.0.dev272.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=x26AIwDzScUvnX-p4xlq6Zc5QYrAo0Vmgf1qHc1KL_M,8253
-omlish/__about__.py,sha256=a-BsHYkG1XmGNuahLQVSE6wR7i-00PDzWGTjEenZsC0,3380
+omlish/__about__.py,sha256=sBVk_BgCjXDv-7KkFlDdOfXgB8qnaGdomycyZCp2gHA,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -776,9 +776,15 @@ omlish/text/parts.py,sha256=Q9NvoyEGQKIWgiPD4D_Qc66cWAuyEKE033dT9m7c3Wk,6662
 omlish/text/random.py,sha256=8feS5JE_tSjYlMl-lp0j93kCfzBae9AM2cXlRLebXMA,199
 omlish/text/go/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/text/go/quoting.py,sha256=N9EYdnFdEX_A8fOviH-1w4jwV3XOQ7VU2WsoUNubYVY,9137
-omlish-0.0.0.dev271.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev271.dist-info/METADATA,sha256=SXISrSK-Lmc1Z9EwMNS_ex2iPPZeBFhAoayeCdlukGw,4198
-omlish-0.0.0.dev271.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-omlish-0.0.0.dev271.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev271.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev271.dist-info/RECORD,,
+omlish/typedvalues/__init__.py,sha256=9ROZq46KN2scNUckjMaSiUiXxP3a_-8_lnOh_eBF5RM,357
+omlish/typedvalues/accessor.py,sha256=gZ48yDFRYS_0TgbRBY6Pxa50ncWCqwaGes_T_RWLTvo,2738
+omlish/typedvalues/collection.py,sha256=XTAmxo_QlhaIUM-oFif-kDxxi3esQ5E1p99NSHsqRn0,3496
+omlish/typedvalues/generic.py,sha256=byWG_gMXhNelckUwdmOoJE9FKkL71Q4BSi4ZLyy0XZ0,788
+omlish/typedvalues/holder.py,sha256=4SwRezsmuDDEO5gENGx8kTm30pblF5UktoEAu02i-Gk,1554
+omlish/typedvalues/values.py,sha256=DPq490iKm_Ny_pUa2tmSzMuITAZDGhIt969OaphFROg,892
+omlish-0.0.0.dev272.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev272.dist-info/METADATA,sha256=XTYfFdON0tX-aBDW2Bo_n7ifW_sx1zE9oCg_2MWqmuo,4198
+omlish-0.0.0.dev272.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+omlish-0.0.0.dev272.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev272.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev272.dist-info/RECORD,,