omlish 0.0.0.dev271__tar.gz → 0.0.0.dev272__tar.gz

{omlish-0.0.0.dev271/omlish.egg-info → omlish-0.0.0.dev272}/PKG-INFO

@@ -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 → omlish-0.0.0.dev272}/omlish/__about__.py

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

omlish-0.0.0.dev272/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-0.0.0.dev272/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-0.0.0.dev272/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-0.0.0.dev272/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-0.0.0.dev272/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-0.0.0.dev272/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 → omlish-0.0.0.dev272/omlish.egg-info}/PKG-INFO

@@ -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 → omlish-0.0.0.dev272}/omlish.egg-info/SOURCES.txt

@@ -785,4 +785,10 @@ omlish/text/minja.py
 omlish/text/parts.py
 omlish/text/random.py
 omlish/text/go/__init__.py
-omlish/text/go/quoting.py
+omlish/text/go/quoting.py
+omlish/typedvalues/__init__.py
+omlish/typedvalues/accessor.py
+omlish/typedvalues/collection.py
+omlish/typedvalues/generic.py
+omlish/typedvalues/holder.py
+omlish/typedvalues/values.py

{omlish-0.0.0.dev271 → omlish-0.0.0.dev272}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev271'
+version = '0.0.0.dev272'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',