omlish 0.0.0.dev293__tar.gz → 0.0.0.dev295__tar.gz

{omlish-0.0.0.dev293/omlish.egg-info → omlish-0.0.0.dev295}/PKG-INFO

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

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev293'
-__revision__ = 'ef66d2ef2f66a131fc0f8498c584d603f252a39e'
+__version__ = '0.0.0.dev295'
+__revision__ = 'eb4e318f611f286b283b0afe04a4d6acb13ca8ee'
 
 
 #

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295}/omlish/secrets/secrets.py

@@ -67,10 +67,10 @@ class SecretRef:
 SecretRefOrStr: ta.TypeAlias = SecretRef | str
 
 
-def secret_repr(o: SecretRefOrStr | None) -> str | None:
+def secret_repr(o: Secret | SecretRef | str | None) -> str | None:
     if isinstance(o, str):
         return '...'
-    elif isinstance(o, SecretRef):
+    elif isinstance(o, (Secret, SecretRef)):
         return repr(o)
     elif o is None:
         return None

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295}/omlish/typedvalues/__init__.py

@@ -8,6 +8,12 @@ from .collection import (  # noqa
     TypedValues,
 )
 
+from .consumer import (  # noqa
+    UnconsumedTypedValuesError,
+
+    TypedValuesConsumer,
+)
+
 from .generic import (  # noqa
     TypedValueGeneric,
 )

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295}/omlish/typedvalues/accessor.py

@@ -6,6 +6,7 @@ TODO:
 import abc
 import typing as ta
 
+from .. import check
 from .. import lang
 from .values import TypedValue  # noqa
 from .values import UniqueTypedValue  # noqa
@@ -22,6 +23,10 @@ UniqueTypedValueU = ta.TypeVar('UniqueTypedValueU', bound='UniqueTypedValue')
 ##
 
 
+class _NOT_SET(lang.Marker):  # noqa
+    pass
+
+
 class TypedValuesAccessor(lang.Abstract, ta.Generic[TypedValueT]):
     def __iter__(self):
         raise TypeError(
@@ -97,17 +102,20 @@ class TypedValuesAccessor(lang.Abstract, ta.Generic[TypedValueT]):
         ...
 
     @ta.final
-    def get(self, key, /, default=None):
+    def get(self, key, /, default=_NOT_SET):
         if not isinstance(key, type):
-            if default is not None:
+            if default is not _NOT_SET:
                 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
+        elif default is _NOT_SET:
+            default = None
+
+        check.issubclass(key, TypedValue)
+        try:
+            return self._typed_value_getitem(key)
+        except KeyError:
+            return default
 
     #
 

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295}/omlish/typedvalues/collection.py

@@ -4,6 +4,7 @@ from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .accessor import TypedValuesAccessor
+from .consumer import TypedValuesConsumer
 from .values import TypedValue
 from .values import UniqueTypedValue
 
@@ -28,7 +29,12 @@ class TypedValues(
     lang.Final,
     ta.Generic[TypedValueT],
 ):
-    def __init__(self, *tvs: TypedValueT, override: bool = False) -> None:
+    def __init__(
+            self,
+            *tvs: TypedValueT,
+            override: bool = False,
+            check_type: type | tuple[type, ...] | None = None,
+    ) -> None:
         if hasattr(self, '_tup'):
             # When __new__ returns the empty singleton __init__ will still be called.
             if self is not self._EMPTY:
@@ -40,6 +46,8 @@ class TypedValues(
         tmp: list = []
         udct: dict = {}
         for tv in tvs:
+            if check_type is not None:
+                check.isinstance(tv, check_type)
             if isinstance(tv, UniqueTypedValue):
                 utvc = tv._unique_typed_value_cls  # noqa
                 if not override:
@@ -175,6 +183,11 @@ class TypedValues(
 
     #
 
+    def consume(self) -> TypedValuesConsumer[TypedValueT]:
+        return TypedValuesConsumer(self._dct.items())
+
+    #
+
     def _typed_value_contains(self, cls):
         return cls in self._dct2
 
@@ -186,18 +199,6 @@ class TypedValues(
         else:
             raise TypeError(key)
 
-    def _typed_value_get(self, key, /, default=None):
-        check.issubclass(key, TypedValue)
-        try:
-            return self._dct2[key]
-        except KeyError:
-            if issubclass(key, UniqueTypedValue):
-                return default
-            elif default is not None:
-                return tuple(default)
-            else:
-                return ()
-
     _any_dct: dict[type, tuple[TypedValueT, ...]]
 
     def _typed_value_get_any(self, cls):
@@ -206,10 +207,12 @@ class TypedValues(
         except AttributeError:
             any_dct = {}
             self._any_dct = any_dct
+
         try:
             return any_dct[cls]
         except KeyError:
             pass
+
         ret = tuple(tv for tv in self if isinstance(tv, cls))
         any_dct[cls] = ret
         return ret

omlish-0.0.0.dev295/omlish/typedvalues/consumer.py

@@ -0,0 +1,175 @@
+# ruff: noqa: UP007
+import dataclasses as dc
+import typing as ta
+
+from .. import check
+from .. import lang
+from .values import ScalarTypedValue
+from .values import TypedValue
+from .values import UniqueTypedValue
+
+
+if ta.TYPE_CHECKING:
+    from . import collection as tvc
+else:
+    tvc = lang.proxy_import('.collection', __package__)
+
+
+TypedValueT = ta.TypeVar('TypedValueT', bound=TypedValue)
+TypedValueU = ta.TypeVar('TypedValueU', bound=TypedValue)
+
+UniqueTypedValueU = ta.TypeVar('UniqueTypedValueU', bound=UniqueTypedValue)
+
+
+##
+
+
+@dc.dataclass()
+class UnconsumedTypedValuesError(Exception):
+    values: ta.Sequence[TypedValue]
+
+
+class _NOT_SET(lang.Marker):  # noqa
+    pass
+
+
+class TypedValuesConsumer(ta.Generic[TypedValueT]):
+    def __init__(
+            self,
+            src: ta.Union[
+                'tvc.TypedValues',
+                ta.Iterable[tuple[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]]],
+                ta.Mapping[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]],
+            ],
+    ) -> None:
+        super().__init__()
+
+        kvs: ta.Iterable[tuple[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]]]
+        if isinstance(src, tvc.TypedValues):
+            kvs = src.items()
+        elif isinstance(src, ta.Mapping):
+            kvs = src.items()
+        else:
+            kvs = src
+
+        dct: dict = {}
+        for k, v in kvs:
+            check.not_in(k, dct)
+            dct[k] = v
+
+        self._dct: dict[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]] = dct
+
+    #
+
+    def check_empty(self) -> None:
+        if bool(self._dct):
+            raise UnconsumedTypedValuesError(list(self))
+
+    def __enter__(self) -> 'TypedValuesConsumer[TypedValueT]':
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.check_empty()
+
+    #
+
+    def __iter__(self) -> ta.Iterator[TypedValueT]:
+        for v in self._dct.values():
+            if isinstance(v, tuple):
+                yield from v
+            else:
+                yield v
+
+    def __len__(self) -> int:
+        return len(self._dct)
+
+    def __bool__(self) -> bool:
+        return bool(self._dct)
+
+    #
+
+    def keys(self) -> ta.KeysView[type[TypedValueT]]:
+        return self._dct.keys()
+
+    def values(self) -> ta.ValuesView[TypedValueT | tuple[TypedValueT, ...]]:
+        return self._dct.values()
+
+    def items(self) -> ta.ItemsView[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]]:
+        return self._dct.items()
+
+    #
+
+    @ta.overload
+    def pop(
+            self,
+            tv: UniqueTypedValueU,
+    ) -> UniqueTypedValueU:
+        ...
+
+    @ta.overload
+    def pop(
+            self,
+            cls: type[UniqueTypedValueU],
+            /,
+            default: UniqueTypedValueU,
+    ) -> UniqueTypedValueU:
+        ...
+
+    @ta.overload
+    def pop(
+            self,
+            cls: type[UniqueTypedValueU],
+            /,
+            default: UniqueTypedValueU | None,
+    ) -> UniqueTypedValueU | None:
+        ...
+
+    @ta.overload
+    def pop(
+            self,
+            cls: type[TypedValueU],
+    ) -> ta.Sequence[TypedValueU]:
+        ...
+
+    @ta.overload
+    def pop(
+            self,
+            cls: type[TypedValueU],
+            /,
+            default: ta.Iterable[TypedValueU],
+    ) -> ta.Sequence[TypedValueU]:
+        ...
+
+    def pop(self, key, /, default=_NOT_SET):
+        if not isinstance(key, type):
+            if default is not _NOT_SET:
+                raise RuntimeError('Must not provide both an instance key and a default')
+            default = key
+            key = type(default)
+
+        if (
+                issubclass(key, UniqueTypedValue) and
+                (utvc := key._unique_typed_value_cls) is not key  # noqa
+        ):
+            key = utvc
+
+        try:
+            return self._dct.pop(key)
+        except KeyError:
+            if default is not _NOT_SET:
+                return default
+            else:
+                raise
+
+    #
+
+    def pop_scalar_kwargs(self, **kwargs: type[TypedValueT]) -> dict[str, TypedValueT]:
+        dct: dict[str, TypedValueT] = {}
+        for k, vc in kwargs.items():
+            check.issubclass(vc, ScalarTypedValue)
+            try:
+                v = self.pop(vc)
+            except KeyError:
+                continue
+            dct[k] = v.v  # type: ignore[attr-defined]
+        return dct

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295}/omlish/typedvalues/holder.py

@@ -1,16 +1,14 @@
 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')
+TypedValueT = ta.TypeVar('TypedValueT', bound=TypedValue)
 
 
 ##
@@ -43,17 +41,6 @@ class TypedValueHolder(
         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)

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295}/omlish.egg-info/SOURCES.txt

@@ -837,6 +837,7 @@ omlish/text/go/quoting.py
 omlish/typedvalues/__init__.py
 omlish/typedvalues/accessor.py
 omlish/typedvalues/collection.py
+omlish/typedvalues/consumer.py
 omlish/typedvalues/generic.py
 omlish/typedvalues/holder.py
 omlish/typedvalues/marshal.py

{omlish-0.0.0.dev293 → omlish-0.0.0.dev295}/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.dev293'
+version = '0.0.0.dev295'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',