omlish 0.0.0.dev292__tar.gz → 0.0.0.dev294__tar.gz

{omlish-0.0.0.dev292/omlish.egg-info → omlish-0.0.0.dev294}/PKG-INFO

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

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev292'
-__revision__ = '049add36e73b2356410aa68bca39c19cff8047d2'
+__version__ = '0.0.0.dev294'
+__revision__ = 'a8c5ea178d6688aa3681c24ef971c6e24d1eb392'
 
 
 #

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/configs/all.py

@@ -1,4 +1,8 @@
 # ruff: noqa: I001
+from .classes import (  # noqa
+    Configurable,
+)
+
 from .formats import (  # noqa
     ConfigData as Data,
 

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/configs/classes.py

@@ -8,6 +8,9 @@ from .. import lang
 ConfigurableConfigT = ta.TypeVar('ConfigurableConfigT', bound='Configurable.Config')
 
 
+##
+
+
 class Configurable(ta.Generic[ConfigurableConfigT], lang.Abstract):
     @dc.dataclass(frozen=True, kw_only=True)
     class Config:

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/dataclasses/api/classes/decorator.py

@@ -15,7 +15,9 @@ from ...utils import class_decorator
 from ..fields.building import build_cls_std_fields
 from ..fields.conversion import std_field_to_field_spec
 from .metadata import extract_cls_metadata
+from .params import STD_PARAM_DEFAULTS
 from .params import build_spec_std_params
+from .params import get_class_spec
 
 
 ##
@@ -47,11 +49,19 @@ def dataclass(
         cache_hash: bool | None = None,
         generic_init: bool | None = None,
         override: bool | None = None,
+
         repr_id: bool | None = None,
+        terse_repr: bool | None = None,
+
+        allow_redundant_decorator: bool | None = None,
 
         #
 
         _plan_only: bool = False,
+
+        #
+
+        _kwargs: ta.Mapping[str, ta.Any] | None = None,
 ):
     if isinstance(metadata, ta.Mapping):
         raise TypeError(metadata)
@@ -60,6 +70,27 @@ def dataclass(
 
     cls = check.not_none(cls)
 
+    if STD_PARAMS_ATTR in cls.__dict__:
+        if (xcs := get_class_spec(cls)) is not None and xcs.allow_redundant_decorator:
+            xpd = {
+                a: getattr(xcs, a)
+                for a in STD_PARAM_DEFAULTS
+            }
+
+            dpd = {
+                **STD_PARAM_DEFAULTS,
+                **{k: v for k, v in (_kwargs or {}).items() if k in STD_PARAM_DEFAULTS},
+            }
+
+            if xpd == dpd:
+                check.in_(STD_FIELDS_ATTR, cls.__dict__)
+                return cls
+
+        raise TypeError(cls)
+
+    check.not_in(STD_PARAMS_ATTR, cls.__dict__)
+    check.not_in(STD_FIELDS_ATTR, cls.__dict__)
+
     #
 
     fields = build_cls_std_fields(
@@ -122,7 +153,11 @@ def dataclass(
                 cache_hash=cache_hash,
                 generic_init=generic_init,
                 override=override,
+
                 repr_id=repr_id,
+                terse_repr=terse_repr,
+
+                allow_redundant_decorator=allow_redundant_decorator,
             ),
         },
 
@@ -133,7 +168,6 @@ def dataclass(
     #
 
     std_params = build_spec_std_params(cs)
-    check.not_in(STD_PARAMS_ATTR, cls.__dict__)
     setattr(cls, STD_PARAMS_ATTR, std_params)
 
     #

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/dataclasses/api/classes/make.py

@@ -39,7 +39,11 @@ def make_dataclass(  # noqa
         cache_hash: bool | None = None,
         generic_init: bool | None = None,
         override: bool | None = None,
+
         repr_id: bool | None = None,
+        terse_repr: bool | None = None,
+
+        allow_redundant_decorator: bool | None = None,
 ):
     if namespace is None:
         namespace = {}
@@ -105,5 +109,9 @@ def make_dataclass(  # noqa
         cache_hash=cache_hash,
         generic_init=generic_init,
         override=override,
+
         repr_id=repr_id,
+        terse_repr=terse_repr,
+
+        allow_redundant_decorator=allow_redundant_decorator,
     )

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/dataclasses/api/classes/params.py

@@ -9,6 +9,26 @@ from ...specs import ClassSpec
 ##
 
 
+STD_PARAM_DEFAULTS: ta.Mapping[str, ta.Any] = dict(
+    init=True,
+    repr=True,  # noqa
+    eq=True,
+    order=False,
+    unsafe_hash=False,
+    frozen=False,
+
+    match_args=True,
+    kw_only=False,
+    slots=False,
+    weakref_slot=False,
+)
+
+STD_PARAM_ATTRS: tuple[str, ...] = tuple(STD_PARAM_DEFAULTS)
+
+
+##
+
+
 class SpecDataclassParams(StdParams):
     __slots__ = (*StdParams.__slots__, '_spec')
 

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/dataclasses/concerns/repr.py

@@ -11,25 +11,27 @@ from ..generation.ops import OpRef
 from ..generation.ops import Ref
 from ..generation.registry import register_generator_type
 from ..processing.base import ProcessingContext
+from ..specs import FieldSpec
 from ..specs import FieldType
 from ..specs import ReprFn
+from .fields import InitFields
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, kw_only=True)
 class ReprPlan(Plan):
-    fields: tuple[str, ...]
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Field:
+        name: str
+        kw_only: bool = False
+        fn: OpRef[ReprFn] | None = None
 
-    @dc.dataclass(frozen=True)
-    class Fn:
-        field: str
-        fn: OpRef[ReprFn]
-
-    fns: tuple[Fn, ...] = ()
+    fields: tuple[Field, ...]
 
     id: bool = False
+    terse: bool = False
 
 
 @register_generator_type(ReprPlan)
@@ -38,22 +40,37 @@ class ReprGenerator(Generator[ReprPlan]):
         if not ctx.cs.repr or '__repr__' in ctx.cls.__dict__:
             return None
 
-        fs = sorted(ctx.cs.fields, key=lambda f: f.repr_priority or 0)
+        ifs = ctx[InitFields]
+        fs: ta.Sequence[FieldSpec]
+        if ctx.cs.terse_repr:
+            # If terse repr will match init param order
+            fs = ifs.all
+        else:
+            # Otherwise default to dc.fields() order
+            fs = sorted(ctx.cs.fields, key=lambda f: f.repr_priority or 0)
 
         orm = {}
-        rfs: list[ReprPlan.Fn] = []
+        rfs: list[ReprPlan.Field] = []
         for i, f in enumerate(fs):
-            if f.repr_fn is None:
+            if not (f.field_type is FieldType.INSTANCE and f.repr):
                 continue
-            r: OpRef = OpRef(f'repr.fns.{i}.fn')
-            orm[r] = f.repr_fn
-            rfs.append(ReprPlan.Fn(f.name, r))
+
+            fnr: OpRef | None = None
+            if f.repr_fn is not None:
+                fnr = OpRef(f'repr.fns.{i}.fn')
+                orm[fnr] = f.repr_fn
+
+            rfs.append(ReprPlan.Field(
+                name=f.name,
+                kw_only=f in ifs.kw_only,
+                fn=fnr,
+            ))
 
         return PlanResult(
             ReprPlan(
-                fields=tuple(f.name for f in fs if f.field_type is FieldType.INSTANCE and f.repr),
-                fns=tuple(rfs),
+                fields=tuple(rfs),
                 id=ctx.cs.repr_id,
+                terse=ctx.cs.terse_repr,
             ),
             orm,
         )
@@ -63,17 +80,20 @@ class ReprGenerator(Generator[ReprPlan]):
 
         part_lines: list[str] = []
 
-        rfd = {rf.field: rf.fn for rf in pl.fns}
         for f in pl.fields:
-            if (rf := rfd.get(f)) is not None:
-                ors.add(rf)
+            pfx = ''
+            if not (pl.terse and not f.kw_only):
+                pfx = f'{f.name}='
+
+            if f.fn is not None:
+                ors.add(f.fn)
                 part_lines.extend([
-                    f'    if (s := {rf.ident()}(self.{f})) is not None:',
-                    f'        parts.append(f"{f}={{s}}")',
+                    f'    if (s := {f.fn.ident()}(self.{f.name})) is not None:',
+                    f'        parts.append(f"{pfx}{{s}}")',
                 ])
             else:
                 part_lines.append(
-                    f'    parts.append(f"{f}={{self.{f}!r}}")',
+                    f'    parts.append(f"{pfx}{{self.{f.name}!r}}")',
                 )
 
         return [

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/dataclasses/metaclass/bases.py

@@ -1,5 +1,6 @@
 import typing as ta
 
+from ..api.classes.decorator import dataclass
 from ..concerns.frozen import unchecked_frozen_base
 from .meta import DataMeta
 from .specs import get_metaclass_spec
@@ -16,9 +17,11 @@ T = ta.TypeVar('T')
 class Data(
     eq=False,
     order=False,
+    allow_redundant_decorator=True,
     confer=frozenset([
         'confer',
         'final_subclasses',
+        'allow_redundant_decorator',
     ]),
     metaclass=DataMeta,
 ):
@@ -31,6 +34,9 @@ class Data(
         super().__init_subclass__(**kwargs)
 
 
+#
+
+
 class Frozen(
     Data,
     frozen=True,
@@ -47,6 +53,9 @@ class Frozen(
     pass
 
 
+#
+
+
 class Case(
     Frozen,
     abstract=True,
@@ -57,13 +66,19 @@ class Case(
     pass
 
 
+#
+
+
+@dataclass(frozen=True)
 class Box(
     Frozen,
     ta.Generic[T],
     generic_init=True,
+    terse_repr=True,
     confer=frozenset([
         *get_metaclass_spec(Frozen).confer,
         'generic_init',
+        'terse_repr',
     ]),
 ):
     v: T

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/dataclasses/metaclass/confer.py

@@ -17,6 +17,11 @@ CONFER_CLASS_PARAMS: tuple[str, ...] = (
     'cache_hash',
     'generic_init',
     'override',
+
+    'repr_id',
+    'terse_repr',
+
+    'allow_redundant_decorator',
 )
 
 CONFER_METACLASS_PARAMS: tuple[str, ...] = (

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/dataclasses/specs.py

@@ -183,7 +183,11 @@ class ClassSpec(lang.Final):
     cache_hash: bool = False
     generic_init: bool = False
     override: bool = False
+
     repr_id: bool = False
+    terse_repr: bool = False
+
+    allow_redundant_decorator: bool = False
 
     ##
     # callbacks

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/dataclasses/utils.py

@@ -75,7 +75,7 @@ def class_decorator(fn):
     @functools.wraps(fn)
     def inner(cls=None, *args, **kwargs):
         if cls is None:
-            return lambda cls: fn(cls, *args, **kwargs)  # noqa
+            return lambda cls: fn(cls, *args, _kwargs=kwargs, **kwargs)  # noqa
         return fn(cls, *args, **kwargs)
     return inner
 

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/formats/json5/parsing.py

@@ -1,8 +1,7 @@
 # ruff: noqa: N802 N803
 import typing as ta
 
-from omlish import antlr
-
+from ... import antlr
 from ._antlr.Json5Lexer import Json5Lexer  # type: ignore
 from ._antlr.Json5Parser import Json5Parser  # type: ignore
 from ._antlr.Json5Visitor import Json5Visitor  # type: ignore

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/secrets/all.py

@@ -15,6 +15,8 @@ from .secrets import (  # noqa
     secret_repr,
 )
 
+ref = SecretRef
+
 
 ##
 

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/secrets/secrets.py

@@ -59,6 +59,7 @@ class Secret(lang.NotPicklable, lang.Sensitive, lang.Final):
 
 
 @dc.dataclass(frozen=True)
+@dc.extra_class_params(terse_repr=True)
 class SecretRef:
     key: str
 
@@ -66,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.dev292 → omlish-0.0.0.dev294}/omlish/text/filecache.py

@@ -131,7 +131,7 @@ class TextFileCache:
 
     #
 
-    def _normalize_path(self, path: str) -> str:
+    def normalize_path(self, path: str) -> str:
         return abs_real_path(path)
 
     #
@@ -217,7 +217,7 @@ class TextFileCache:
             check_stat: bool = False,
             or_raise: bool = False,
     ) -> Entry:
-        path = self._normalize_path(path)
+        path = self.normalize_path(path)
 
         with self._lock:
             return self._get_entry(
@@ -229,7 +229,7 @@ class TextFileCache:
     #
 
     def invalidate(self, path: str) -> bool:
-        path = self._normalize_path(path)
+        path = self.normalize_path(path)
 
         with self._lock:
             return self._dct.pop(path, None) is not None

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/omlish/typedvalues/__init__.py

@@ -8,6 +8,12 @@ from .collection import (  # noqa
     TypedValues,
 )
 
+from .consumer import (  # noqa
+    UnconsumedTypedValuesError,
+
+    TypedValuesConsumer,
+)
+
 from .generic import (  # noqa
     TypedValueGeneric,
 )
@@ -26,6 +32,8 @@ from .values import (  # noqa
     UniqueTypedValue,
 
     ScalarTypedValue,
+
+    UniqueScalarTypedValue,
 )
 
 

{omlish-0.0.0.dev292 → omlish-0.0.0.dev294}/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(
@@ -32,7 +37,7 @@ class TypedValuesAccessor(lang.Abstract, ta.Generic[TypedValueT]):
 
     @ta.final
     def __contains__(self, cls: type[TypedValueU]) -> bool:
-        raise NotImplementedError
+        return self._typed_value_contains(cls)
 
     @abc.abstractmethod
     def _typed_value_contains(self, cls):
@@ -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.dev292 → omlish-0.0.0.dev294}/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:
@@ -65,7 +73,6 @@ class TypedValues(
                 if idx == len(ulst):
                     lst.append(tv)
                     dct[utvc] = tv
-                    dct[type(tv)] = tv
             else:
                 tv = obj
                 lst.append(tv)
@@ -76,6 +83,10 @@ class TypedValues(
             k: tuple(v) if isinstance(v, list) else v
             for k, v in dct.items()
         }
+        self._dct2: dict[type[TypedValueT], TypedValueT | tuple[TypedValueT, ...]] = {
+            **self._dct,
+            **{type(v): v for v in self._dct.values() if isinstance(v, UniqueTypedValue)},  # type: ignore[misc]
+        }
 
     #
 
@@ -161,29 +172,33 @@ class TypedValues(
 
     #
 
+    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()
+
+    #
+
+    def consume(self) -> TypedValuesConsumer[TypedValueT]:
+        return TypedValuesConsumer(self._dct.items())
+
+    #
+
     def _typed_value_contains(self, cls):
-        return cls in self._dct
+        return cls in self._dct2
 
     def _typed_value_getitem(self, key):
         if isinstance(key, int):
             return self._tup[key]
         elif isinstance(key, type):
-            return self._dct[check.issubclass(key, TypedValue)]
+            return self._dct2[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 tuple(default)
-            else:
-                return ()
-
     _any_dct: dict[type, tuple[TypedValueT, ...]]
 
     def _typed_value_get_any(self, cls):
@@ -192,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