omlish 0.0.0.dev291__tar.gz → 0.0.0.dev293__tar.gz

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

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

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

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev291'
-__revision__ = '8d0ee885f143f757a01fdd52c57e6c1d2736d375'
+__version__ = '0.0.0.dev293'
+__revision__ = 'ef66d2ef2f66a131fc0f8498c584d603f252a39e'
 
 
 #

{omlish-0.0.0.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/omlish/lang/__init__.py

@@ -96,12 +96,10 @@ from .contextmanagers import (  # noqa
     NOP_CONTEXT_MANAGER,
     NopContextManager,
     Timer,
-    a_defer,
     breakpoint_on_exception,
     context_var_setting,
     context_wrapped,
     default_lock,
-    defer,
     disposing,
     maybe_managing,
 )
@@ -296,9 +294,11 @@ from .typing import (  # noqa
 ##
 
 from ..lite.contextmanagers import (  # noqa
-    attr_setting,
     AsyncExitStacked,
     ExitStacked,
+    adefer,
+    attr_setting,
+    defer,
 )
 
 from ..lite.imports import (  # noqa

{omlish-0.0.0.dev291 → omlish-0.0.0.dev293}/omlish/lang/contextmanagers.py

@@ -119,22 +119,6 @@ class AsyncContextManager(abc.ABC, ta.Generic[T]):
 ##
 
 
-@contextlib.contextmanager
-def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
-    try:
-        yield fn
-    finally:
-        fn()
-
-
-@contextlib.asynccontextmanager
-async def a_defer(fn: ta.Awaitable) -> ta.AsyncGenerator[ta.Awaitable, None]:
-    try:
-        yield fn
-    finally:
-        await fn
-
-
 @contextlib.contextmanager
 def maybe_managing(obj: T) -> ta.Iterator[T]:
     if isinstance(obj, ta.ContextManager):

{omlish-0.0.0.dev291 → omlish-0.0.0.dev293}/omlish/lite/contextmanagers.py

@@ -1,5 +1,6 @@
 # ruff: noqa: UP007
 import contextlib
+import functools
 import sys
 import typing as ta
 
@@ -146,7 +147,9 @@ class AsyncExitStacked:
 
 
 @contextlib.contextmanager
-def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
+def defer(fn: ta.Callable, *args: ta.Any, **kwargs: ta.Any) -> ta.Generator[ta.Callable, None, None]:
+    if args or kwargs:
+        fn = functools.partial(fn, *args, **kwargs)
     try:
         yield fn
     finally:
@@ -154,11 +157,11 @@ def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
 
 
 @contextlib.asynccontextmanager
-async def adefer(fn: ta.Callable) -> ta.AsyncGenerator[ta.Callable, None]:
+async def adefer(fn: ta.Awaitable) -> ta.AsyncGenerator[ta.Awaitable, None]:
     try:
         yield fn
     finally:
-        await fn()
+        await fn
 
 
 ##

{omlish-0.0.0.dev291 → omlish-0.0.0.dev293}/omlish/secrets/all.py

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

{omlish-0.0.0.dev291 → omlish-0.0.0.dev293}/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
 

omlish-0.0.0.dev293/omlish/subprocesses/editor.py

@@ -0,0 +1,97 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import dataclasses as dc
+import os
+import tempfile
+import typing as ta
+
+from ..lite.cached import cached_nullary
+from ..lite.contextmanagers import ExitStacked
+from ..lite.contextmanagers import defer
+from .run import SubprocessRun
+from .run import SubprocessRunnable
+from .run import SubprocessRunOutput
+
+
+##
+
+
+class EditTextWithUserEditor(SubprocessRunnable, ExitStacked):
+    def __init__(self, initial_text: str = '') -> None:
+        super().__init__()
+
+        self._initial_text = initial_text
+
+    @dc.dataclass(frozen=True)
+    class _TempFile:
+        path: str
+        before_mtime: float
+
+    @cached_nullary
+    def _temp_file(self) -> _TempFile:
+        with tempfile.NamedTemporaryFile(
+                mode='r+',
+                delete=False,
+        ) as ntf:
+            ntf.write(self._initial_text)
+            ntf.flush()
+            before_mtime = os.stat(ntf.name).st_mtime
+
+        self._enter_context(defer(os.unlink, ntf.name))  # noqa
+
+        return EditTextWithUserEditor._TempFile(
+            ntf.name,
+            before_mtime,
+        )
+
+    def make_run(self) -> SubprocessRun:
+        tf = self._temp_file()
+
+        editor = os.environ.get('EDITOR', 'vi')
+
+        return SubprocessRun.of(
+            editor,
+            tf.path,
+        )
+
+    def handle_run_output(self, output: SubprocessRunOutput) -> ta.Optional[str]:
+        tf = self._temp_file()
+
+        if output.returncode != 0:
+            return None
+
+        after_mtime = os.stat(tf.path).st_mtime
+
+        if after_mtime == tf.before_mtime:
+            # No changes made; assuming cancel.
+            return None
+
+        with open(tf.path) as f:
+            content = f.read().strip()
+            if not content:
+                # Empty file; assuming cancel.
+                return None
+
+        return content
+
+
+def edit_text_with_user_editor(
+        initial_text: str = '',
+        subprocesses: ta.Optional[ta.Any] = None,  # AbstractSubprocesses
+) -> ta.Optional[str]:
+    with EditTextWithUserEditor(initial_text) as cmd:
+        return cmd.run(subprocesses)
+
+
+##
+
+
+if __name__ == '__main__':
+    def _main() -> None:
+        text = edit_text_with_user_editor('# Write your message here.\n')
+        if text is not None:
+            print('User submitted:\n', text)
+        else:
+            print('Operation canceled.')
+
+    _main()

{omlish-0.0.0.dev291 → omlish-0.0.0.dev293}/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.dev291 → omlish-0.0.0.dev293}/omlish/typedvalues/__init__.py

@@ -26,6 +26,8 @@ from .values import (  # noqa
     UniqueTypedValue,
 
     ScalarTypedValue,
+
+    UniqueScalarTypedValue,
 )
 
 

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

@@ -32,7 +32,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):

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

@@ -65,7 +65,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 +75,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,21 +164,32 @@ 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 _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]
+            return self._dct2[key]
         except KeyError:
             if issubclass(key, UniqueTypedValue):
                 return default