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

omlish/__about__.py

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

omlish/dataclasses/impl/api.py

@@ -11,6 +11,7 @@ import types
 import typing as ta
 
 from ... import check as check_
+from ... import lang
 from .internals import PARAMS_ATTR
 from .internals import Params
 from .main import process_class
@@ -40,20 +41,26 @@ def field(  # noqa
         check_type: bool | type | tuple[type | None, ...] | None = None,
         override: bool = False,
         repr_fn: ta.Callable[[ta.Any], str | None] | None = None,
+        repr_priority: int | None = None,
         frozen: bool | None = None,
 ):  # -> dc.Field
     if default is not MISSING and default_factory is not MISSING:
         raise ValueError('cannot specify both default and default_factory')
 
-    fx = FieldExtras(
+    fx = FieldExtras()
+    if metadata is not None:
+        fx = metadata.get(FieldExtras, fx)
+
+    fx = dc.replace(fx, **lang.opt_kw(
         derive=derive,
         coerce=coerce,
         validate=validate,
         check_type=check_type,
         override=override,
         repr_fn=repr_fn,
+        repr_priority=repr_priority,
         frozen=frozen,
-    )
+    ))
 
     md: ta.Mapping = {FieldExtras: fx}
     if metadata is not None:

omlish/dataclasses/impl/params.py

@@ -53,6 +53,7 @@ class FieldExtras(lang.Final):
     check_type: bool | type | tuple[type | None, ...] | None = None
     override: bool = False
     repr_fn: ta.Callable[[ta.Any], str | None] | None = None
+    repr_priority: int | None = None
     frozen: bool | None = None  # TODO
 
 

omlish/dataclasses/impl/repr.py

@@ -14,6 +14,9 @@ def repr_fn(
         globals: Namespace,  # noqa
 ) -> ta.Callable:
     locals: dict[str, ta.Any] = {}  # noqa
+
+    fields = sorted(fields, key=lambda f: get_field_extras(f).repr_priority or 0)
+
     if any(get_field_extras(f).repr_fn is not None for f in fields):
         lst: list[str] = []
         for f in fields:
@@ -22,17 +25,20 @@ def repr_fn(
                 lst.append(f"if (r := {fn_name}(self.{f.name})) is not None: l.append(f'{f.name}={{r}}')")
             else:
                 lst.append(f"l.append(f'{f.name}={{self.{f.name}!r}}')")
+
         src = [
             'l = []',
             *lst,
             'return f"{self.__class__.__qualname__}({", ".join(l)})"',
         ]
+
     else:
         src = [
             'return f"{self.__class__.__qualname__}(' +
             ', '.join([f'{f.name}={{self.{f.name}!r}}' for f in fields]) +
             ')"',
         ]
+
     fn = create_fn(
         '__repr__',
         ('self',),
@@ -40,6 +46,7 @@ def repr_fn(
         globals=globals,
         locals=locals,
     )
+
     return reprlib.recursive_repr()(fn)
 
 

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.dev270.dist-info → omlish-0.0.0.dev272.dist-info}/METADATA

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

{omlish-0.0.0.dev270.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=OR-PRiAN7dudUKnLMzl2lt9Y5bh8Gy1c1V-wJvtHqLA,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
@@ -206,7 +206,7 @@ omlish/dataclasses/static.py,sha256=6pZG2iTR9NN8pKm-5ukDABnaVlTKFOzMwkg-rbxURoo,
 omlish/dataclasses/utils.py,sha256=BTXYyH0enSEP5kWxMnPTJ8_UPd7h4wF2RVPITNC8H4M,3872
 omlish/dataclasses/impl/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
 omlish/dataclasses/impl/__init__.py,sha256=zqGBC5gSbjJxaqG_zS1LL1PX-zAfhIua8UqOE4IwO2k,789
-omlish/dataclasses/impl/api.py,sha256=RhU4f50GVdn-dxilia8NA3F7VIm2R5z78pFfpIVXPRQ,6635
+omlish/dataclasses/impl/api.py,sha256=Sl3DhCLn8KCvsXAOahr7VP_EH9XqBu9TBt3MQ9WqLbo,6849
 omlish/dataclasses/impl/as_.py,sha256=CD-t7hkC1EP2F_jvZKIA_cVoDuwZ-Ln_xC4fJumPYX0,2598
 omlish/dataclasses/impl/copy.py,sha256=Tn8_n6Vohs-w4otbGdubBEvhd3TsSTaM3EfNGdS2LYo,591
 omlish/dataclasses/impl/descriptors.py,sha256=jSYNkKdy2rKddGpQqRwNuhw-ggpcvp_SWHpLwIWPOzc,2474
@@ -221,11 +221,11 @@ omlish/dataclasses/impl/metaclass.py,sha256=ebxJr3j8d_wz-fc7mvhWtJ6wJgnxVV6rVOQd
 omlish/dataclasses/impl/metadata.py,sha256=4veWwTr-aA0KP-Y1cPEeOcXHup9EKJTYNJ0ozIxtzD4,1401
 omlish/dataclasses/impl/order.py,sha256=zWvWDkSTym8cc7vO1cLHqcBhhjOlucHOCUVJcdh4jt0,1369
 omlish/dataclasses/impl/overrides.py,sha256=g9aCzaDDKyek8-yXRvtAcu1B1nCphWDYr4InHDlgbKk,1732
-omlish/dataclasses/impl/params.py,sha256=9EHn7PxqPVtRPcNDNDCsbcmxvkezWR5LzLLxCua2Vok,2946
+omlish/dataclasses/impl/params.py,sha256=lmZkxZlZWPEPXmC-__P_3ZZeyL7IoQxli15mM3kUUsU,2983
 omlish/dataclasses/impl/processing.py,sha256=DFxyFjL_h3awRyF_5eyTnB8QkuApx7Zc4QFnVoltlao,459
 omlish/dataclasses/impl/reflect.py,sha256=1PTxx3ycsWhC3oAV71mW-ZquDRwa2-t9uIaKFO8ab8U,5468
 omlish/dataclasses/impl/replace.py,sha256=wS9GHX4fIwaPv1JBJzIewdBfXyK3X3V7_t55Da87dYo,1217
-omlish/dataclasses/impl/repr.py,sha256=oLXBTxqp88NKmz82HrJeGiTEiwK4l5LlXQT9Q0-tX3c,1605
+omlish/dataclasses/impl/repr.py,sha256=D6Rnz0tWf8Qy9abIFVV0x1UQFF9ERJd4VsyHmQ9Y2g0,1693
 omlish/dataclasses/impl/simple.py,sha256=Q272TYXifB5iKtydByxyzraeQHX6aXDY0VKO1-AKBF4,1771
 omlish/dataclasses/impl/slots.py,sha256=qXRLbtFWUs_2UV1fFUdv53_6fBLKJ_8McjNiP9YQlGM,5264
 omlish/dataclasses/impl/utils.py,sha256=aER2iL3UAtgS1BdLuEvTr9Tr2wC28wk1kiOeO-jIymw,6138
@@ -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.dev270.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev270.dist-info/METADATA,sha256=yrRv07ARNclD2q_004yblEKJRqGAi5VuRPhmU21-rhU,4198
-omlish-0.0.0.dev270.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-omlish-0.0.0.dev270.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev270.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev270.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,,