omlish 0.0.0.dev484__py3-none-any.whl → 0.0.0.dev506__py3-none-any.whl

omlish/typedvalues/collection.py

@@ -1,3 +1,8 @@
+# ruff: noqa: UP007
+"""
+TODO:
+ - cext _init_typed_values_collection
+"""
 import typing as ta
 
 from .. import check
@@ -19,12 +24,128 @@ UniqueTypedValueT = ta.TypeVar('UniqueTypedValueT', bound='UniqueTypedValue')
 
 
 @dc.dataclass()
-class DuplicateUniqueTypedValueError(Exception, ta.Generic[UniqueTypedValueT]):
-    cls: type[UniqueTypedValueT]
-    new: UniqueTypedValueT
-    old: UniqueTypedValueT
+class DuplicateUniqueTypedValueError(Exception):
+    cls: type
+    new: TypedValue
+    old: TypedValue
 
 
+##
+
+
+def _init_typed_values_collection(
+        *tvs: TypedValueT,
+        override: bool = False,
+        check_type: type | tuple[type, ...] | None = None,
+) -> tuple[
+    tuple[TypedValueT, ...],
+    dict[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]],
+    dict[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]],
+]:
+    if not tvs:
+        return ((), {}, {})
+
+    # Either a non-unique TypedValue or a tuple of the form (unique_tv_cls, tv, unique_lst, idx_in_unique_lst). Notably,
+    # this intermediate list has the 'opposite' form of the returned collections: where the output dicts have a scalar
+    # tv for unique types and a sequence of tv's for non-unique types, this has scalar values for non-unique types and a
+    # tuple (heterogeneous, however) for unique types.
+    tmp_lst: list[ta.Union[
+        TypedValueT,
+        tuple[
+            type,
+            TypedValueT,
+            list[TypedValueT],
+            int,
+        ],
+    ]] = []
+
+    # When override is False duplicate unique values raises early. When override is True, however, last-in-wins. This
+    # could probably rely on dict insertion order preservation and just overwrite in-place, but it's intentionally done
+    # explicitly: preservation of tv ordering in all aspects is crucial, and retention of some intermediates eases
+    # debugging and error reporting.
+    unique_dct: dict[type, list[TypedValueT]] = {}
+
+    for tv in tvs:
+        if check_type is not None:
+            if not isinstance(tv, check_type):
+                raise TypeError(tv)
+
+        if isinstance(tv, UniqueTypedValue):
+            unique_tv_cls = tv._unique_typed_value_cls  # noqa
+
+            if not override:
+                try:
+                    exu = unique_dct[unique_tv_cls]
+                except KeyError:
+                    pass
+                else:
+                    raise DuplicateUniqueTypedValueError(unique_tv_cls, tv, exu[0])
+
+            unique_lst = unique_dct.setdefault(unique_tv_cls, [])
+            unique_lst.append(tv)
+
+            tmp_lst.append((unique_tv_cls, tv, unique_lst, len(unique_lst)))
+
+        elif isinstance(tv, TypedValue):
+            tmp_lst.append(tv)
+
+        else:
+            raise TypeError(tv)
+
+    # The output list with input order preserved and absent of overridden uniques.
+    lst: list[TypedValueT] = []
+
+    # This dict has the expected form: scalar tv's for unique types, and an accumulating list for non-unique types.
+    tmp_dct: dict[type, TypedValueT | list[TypedValueT]] = {}
+
+    for obj in tmp_lst:
+        # Unique type
+        if isinstance(obj, tuple):
+            unique_tv_cls, tv, unique_lst, idx = obj
+
+            # Last-in-wins
+            if idx == len(unique_lst):
+                lst.append(tv)
+                tmp_dct[unique_tv_cls] = tv
+
+        else:
+            tv = obj
+            lst.append(tv)
+            tmp_dct.setdefault(type(tv), []).append(tv)  # type: ignore[union-attr]
+
+    # This is the 'canonical' output dict: scalar tv's for unique types keyed by their unique type, and homogenous
+    # tuples of tv's keyed by their instance type for non-unique types.
+    dct: dict[type, TypedValueT | tuple[TypedValueT, ...]] = {
+        k: tuple(v) if isinstance(v, list) else v
+        for k, v in tmp_dct.items()
+    }
+
+    # This is the secondary output dict: the contents of previous dict in addition to entries of unique tv's keyed by
+    # their instance type. Notably, for unique tv's in which their unique type *is* their instance type (which is
+    # perfectly fine) this will squash together duplicate (k, v) pairs, which is also perfectly fine.
+    dct2: dict[type, TypedValueT | tuple[TypedValueT, ...]] = {
+        **dct,
+        **{type(v): v for v in dct.values() if isinstance(v, UniqueTypedValue)},
+    }
+
+    return (tuple(lst), dct, dct2)
+
+
+##
+
+
+try:
+    from . import _collection  # type: ignore
+except ImportError:
+    pass
+else:
+    _init_typed_values_collection = _collection.init_typed_values_collection  # noqa
+
+
+##
+
+
+@ta.final
 class TypedValues(
     TypedValuesAccessor[TypedValueT],
     lang.Final,
@@ -36,79 +157,55 @@ class TypedValues(
             override: bool = False,
             check_type: type | tuple[type, ...] | None = None,
     ) -> None:
-        super().__init__()
-
-        if tvs:
-            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:
-                        try:
-                            exu = udct[utvc]
-                        except KeyError:
-                            pass
-                        else:
-                            raise DuplicateUniqueTypedValueError(utvc, tv, check.single(exu))
-                    ulst = udct.setdefault(utvc, [])
-                    ulst.append(tv)
-                    tmp.append((utvc, tv, ulst, len(ulst)))
-                elif isinstance(tv, TypedValue):
-                    tmp.append(tv)
-                else:
-                    raise TypeError(tv)
-
-            lst: list = []
-            dct: dict = {}
-            for obj in tmp:
-                if isinstance(obj, tuple):
-                    utvc, tv, ulst, idx = obj
-                    if idx == len(ulst):
-                        lst.append(tv)
-                        dct[utvc] = tv
-                else:
-                    tv = obj
-                    lst.append(tv)
-                    dct.setdefault(type(tv), []).append(tv)
-
-            tup = tuple(lst)
-            dct = {
-                k: tuple(v) if isinstance(v, list) else v
-                for k, v in dct.items()
-            }
-            dct2 = {
-                **dct,
-                **{type(v): v for v in dct.values() if isinstance(v, UniqueTypedValue)},
-            }
+        self._tup, self._dct, self._dct2 = _init_typed_values_collection(*tvs, override=override, check_type=check_type)  # noqa
 
-        else:
-            tup = ()
-            dct = {}
-            dct2 = {}
+    _tup: tuple[TypedValueT, ...]
 
-        self._tup: tuple[TypedValueT, ...] = tup
-        self._dct: dict[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]] = dct
-        self._dct2: dict[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]] = dct2
+    # For non unique types, a map from tv instance type to a tuple of instances of that type. For unique tv types, a map
+    # from tv unique type to the tv for that unique tv type.
+    _dct: dict[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]]
+
+    # The contents of the previous dict in addition to entries from unique tv's keyed by their instance type.
+    _dct2: dict[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]]
 
     #
 
     def without(self, *tys: type) -> ta.Iterator[TypedValueT]:
         for o in self._tup:
-            if isinstance(o, tys):
+            if tys and isinstance(o, tys):
                 continue
             yield o
 
     #
 
-    def update(self, *tvs, override: bool = False) -> 'TypedValues':
-        return TypedValues(*self._tup, *tvs, override=override)
-
     def discard(self, *tys: type) -> 'TypedValues':
+        nl = list(self.without(*tys))
+
+        if len(nl) == len(self._tup):
+            return self
+
         return TypedValues(*self.without(*tys))
 
+    def update(
+            self,
+            *tvs,
+            discard: ta.Iterable[type] | None = None,
+            override: bool = False,
+    ) -> 'TypedValues':
+        if not tvs:
+            return self
+
+        n = TypedValues(
+            *(self.discard(*discard) if discard else self._tup),
+            *tvs,
+            override=override,
+        )
+
+        if lang.seqs_identical(self._tup, n._tup):
+            return self
+
+        return n
+
     #
 
     def __repr__(self) -> str:

omlish/typedvalues/generic.py

@@ -18,10 +18,11 @@ class TypedValueGeneric(lang.Abstract, ta.Generic[TypedValueT]):
     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
+
+        if '_typed_value_type' not in cls.__dict__:
+            cls._typed_value_type = tvt
+        else:
+            check.equal(tvt, cls._typed_value_type)

omlish/typedvalues/values.py

@@ -22,6 +22,12 @@ _UNIQUE_BASES: set[type[TypedValue]] = set()
 
 
 class UniqueTypedValue(TypedValue, lang.Abstract):
+    """
+    Inheritance of this abstract class forms the root / key of a family of mutually exclusive TypedValues.
+
+    The immediately inheriting class may or not be Abstract or Final.
+    """
+
     _unique_typed_value_cls: ta.ClassVar[type[TypedValue]]
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:

{omlish-0.0.0.dev484.dist-info → omlish-0.0.0.dev506.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev484
+Version: 0.0.0.dev506
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -26,11 +26,11 @@ Requires-Dist: zstandard~=0.25; python_version < "3.14" and extra == "all"
 Requires-Dist: brotli~=1.2; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
 Requires-Dist: executing~=2.2; extra == "all"
-Requires-Dist: psutil~=7.1; extra == "all"
+Requires-Dist: psutil~=7.2; extra == "all"
 Requires-Dist: orjson~=3.11; extra == "all"
 Requires-Dist: ujson~=5.11; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
-Requires-Dist: cbor2~=5.7; extra == "all"
+Requires-Dist: cbor2~=5.8; extra == "all"
 Requires-Dist: cloudpickle~=3.1; extra == "all"
 Requires-Dist: httpx[http2]~=0.28; extra == "all"
 Requires-Dist: wrapt~=2.0; extra == "all"
@@ -38,8 +38,9 @@ Requires-Dist: cryptography~=46.0; extra == "all"
 Requires-Dist: sqlalchemy[asyncio]~=2.0; extra == "all"
 Requires-Dist: pg8000~=1.31; extra == "all"
 Requires-Dist: pymysql~=1.1; extra == "all"
+Requires-Dist: snowflake-connector-python~=4.2; extra == "all"
 Requires-Dist: aiomysql~=0.3; extra == "all"
-Requires-Dist: aiosqlite~=0.21; extra == "all"
+Requires-Dist: aiosqlite~=0.22; extra == "all"
 Requires-Dist: asyncpg~=0.31; extra == "all"
 Requires-Dist: apsw~=3.51; extra == "all"
 Requires-Dist: sqlean.py~=3.50; extra == "all"
@@ -68,12 +69,12 @@ Requires-Dist: brotli~=1.2; extra == "compress"
 Provides-Extra: diag
 Requires-Dist: asttokens~=3.0; extra == "diag"
 Requires-Dist: executing~=2.2; extra == "diag"
-Requires-Dist: psutil~=7.1; extra == "diag"
+Requires-Dist: psutil~=7.2; extra == "diag"
 Provides-Extra: formats
 Requires-Dist: orjson~=3.11; extra == "formats"
 Requires-Dist: ujson~=5.11; extra == "formats"
 Requires-Dist: pyyaml~=6.0; extra == "formats"
-Requires-Dist: cbor2~=5.7; extra == "formats"
+Requires-Dist: cbor2~=5.8; extra == "formats"
 Requires-Dist: cloudpickle~=3.1; extra == "formats"
 Provides-Extra: http
 Requires-Dist: httpx[http2]~=0.28; extra == "http"
@@ -86,8 +87,9 @@ Requires-Dist: sqlalchemy[asyncio]~=2.0; extra == "sqlalchemy"
 Provides-Extra: sqldrivers
 Requires-Dist: pg8000~=1.31; extra == "sqldrivers"
 Requires-Dist: pymysql~=1.1; extra == "sqldrivers"
+Requires-Dist: snowflake-connector-python~=4.2; extra == "sqldrivers"
 Requires-Dist: aiomysql~=0.3; extra == "sqldrivers"
-Requires-Dist: aiosqlite~=0.21; extra == "sqldrivers"
+Requires-Dist: aiosqlite~=0.22; extra == "sqldrivers"
 Requires-Dist: asyncpg~=0.31; extra == "sqldrivers"
 Requires-Dist: apsw~=3.51; extra == "sqldrivers"
 Requires-Dist: sqlean.py~=3.50; extra == "sqldrivers"
@@ -167,7 +169,7 @@ dependencies of any kind**.
   - An optional [metaclass](https://github.com/wrmsr/omlish/blob/master/omlish/dataclasses/metaclass) which removes the
     need for re-decorating subclasses (with support for inheritance of dataclass parameters like `frozen`), and some
     basic [base classes](https://github.com/wrmsr/omlish/blob/master/omlish/dataclasses/metaclass/bases.py).
-  - (Nearly finished) support for ahead-of-time / build-time code generation, greatly reducing import times.
+  - Support for ahead-of-time / build-time code generation, significantly reducing import times.
 
   The stdlib-equivalent api is exported in such a way as to appear to be direct aliases for the stdlib api itself,
   simplifying tool support.
@@ -247,6 +249,10 @@ dependencies of any kind**.
     *any-future-event-loop-impl* without having multiple fighting plugins (*[I know, I know](https://xkcd.com/927/)*).
   - **[plugins](https://github.com/wrmsr/omlish/blob/master/omlish/testing/pytest/plugins)** - Various other plugins.
 
+- **[typedvalues](https://github.com/wrmsr/omlish/blob/master/omlish/typedvalues)** - A little toolkit around 'boxed'
+  values, whose 'box' types convey more information than the bare values themselves. A rebellion against kwargs / env
+  vars / giant config objects: instead of `foo(bar=1, baz=2)`, you do `foo(Bar(1), Baz(2))`.
+
 - **[lite](https://github.com/wrmsr/omlish/blob/master/omlish/lite)** - The standard library of 'lite' code. This is the
   only package beneath `lang`, and parts of it are re-exported by it for deduplication. On top of miscellaneous
   utilities it contains a handful of independent, self-contained, significantly simplified 'lite' equivalents of some
@@ -294,7 +300,6 @@ examples are:
 - **anyio** - While lite code must use only asyncio, non-trivial async standard code prefers to be written to anyio.
 - **pytest** - What is used for all standard testing - as lite code has no dependencies of any kind its testing uses
   stdlib's [unittest](https://docs.python.org/3/library/unittest.html).
-- **wrapt** - For (optionally-enabled) injector circular proxies.
 - **sqlalchemy** - The codebase has migrated away from SQLAlchemy in favor of the internal api but it retains it as an
   optional dep to support adapting the internal api to it.