omlish 0.0.0.dev303__tar.gz → 0.0.0.dev305__tar.gz

{omlish-0.0.0.dev303/omlish.egg-info → omlish-0.0.0.dev305}/PKG-INFO

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

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev303'
-__revision__ = '8c675f0f9a5c459eddf54867184cd1da05cff6ac'
+__version__ = '0.0.0.dev305'
+__revision__ = '13f1bfc223e6af63310421aa4ac6133b3f1e0110'
 
 
 #

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/dataclasses/__init__.py

@@ -60,6 +60,7 @@ from .api import (  # noqa
     extra_field_params,
     set_field_metadata,
     update_extra_field_params,
+    with_extra_field_params,
 )
 
 from .errors import (  # noqa
@@ -108,6 +109,10 @@ from .tools.modifiers import (  # noqa
     update_fields,
 )
 
+from .tools.only_ import (  # noqa
+    only,
+)
+
 from .tools.replace import (  # noqa
     deep_replace,
 )

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/dataclasses/api/__init__.py

@@ -18,6 +18,7 @@ from .fields.metadata import (  # noqa
     extra_field_params,
     set_field_metadata,
     update_extra_field_params,
+    with_extra_field_params,
 )
 
 from .fields.constructor import (  # noqa

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/dataclasses/api/fields/metadata.py

@@ -5,6 +5,7 @@ from .... import check
 from .... import lang
 from ...debug import DEBUG
 from ...specs import FieldSpec
+from ...tools.modifiers import field_modifier
 from ...utils import chain_mapping_proxy
 
 
@@ -92,3 +93,10 @@ def update_extra_field_params(
             **(fe if unless_non_default else {}),
         },
     })
+
+
+def with_extra_field_params(**kwargs: ta.Any) -> field_modifier:
+    @field_modifier
+    def inner(f: dc.Field) -> dc.Field:
+        return update_extra_field_params(f, **kwargs)
+    return inner

omlish-0.0.0.dev305/omlish/dataclasses/tools/only_.py

@@ -0,0 +1,45 @@
+import collections.abc
+import typing as ta
+
+from .iter import fields_dict
+
+
+##
+
+
+def _only_test(v: ta.Any) -> bool:
+    if v is None:
+        return False
+    elif isinstance(v, collections.abc.Iterable):
+        return bool(v)
+    else:
+        return True
+
+
+def only(
+        obj: ta.Any,
+        *flds: str,
+        all: bool = False,  # noqa
+        test: ta.Callable[[ta.Any], bool] = _only_test,
+) -> bool:
+    fdct = fields_dict(obj)
+    for fn in flds:
+        if fn not in fdct:
+            raise KeyError(fn)
+
+    rem = set(flds)
+    for fn, f in fdct.items():
+        if not f.compare and fn not in rem:
+            continue
+
+        v = getattr(obj, fn)
+        if test(v):
+            if fn in rem:
+                rem.remove(fn)
+            else:
+                return False
+
+    if rem and all:
+        return False
+
+    return True

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/diag/_pycharm/runhack.py

@@ -24,7 +24,10 @@ DEBUG_ENV_VAR = 'OMLISH_PYCHARM_RUNHACK_DEBUG'
 
 #
 
-_DEFAULT_PTH_FILE_NAME = 'omlish-pycharm-runhack.pth'
+# This hack must run first, before things like '__editable__.foo.pth' files installed by setuptools. pth file processing
+# is sorted by name, so prepend with underscores:
+#   https://github.com/python/cpython/blob/aeb3a6f61af53ed3fbf31f0b3704f49b71ac553c/Lib/site.py#L246
+_DEFAULT_PTH_FILE_NAME = '___omlish-pycharm-runhack.pth'
 
 _DEFAULT_DEBUG = False
 _DEFAULT_ENABLED = True

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/graphs/trees.py

@@ -19,6 +19,9 @@ NodeWalker = ta.Callable[[NodeT], ta.Iterable[NodeT]]
 NodeGenerator = ta.Generator[NodeT, None, None]
 
 
+##
+
+
 class NodeError(ta.Generic[NodeT], Exception):
     def __init__(self, node: NodeT, msg: str, *args, **kwargs) -> None:
         super().__init__(msg, *args, **kwargs)  # noqa
@@ -39,6 +42,9 @@ class UnknownNodeError(NodeError[NodeT]):
         super().__init__(node, f'Unknown node: {node!r}', *args, **kwargs)
 
 
+#
+
+
 class BasicTreeAnalysis(ta.Generic[NodeT]):
     def __init__(
             self,

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/lang/__init__.py

@@ -231,6 +231,7 @@ from .maybes import (  # noqa
 )
 
 from .objects import (  # noqa
+    Identity,
     SimpleProxy,
     anon_object,
     arg_repr,
@@ -269,6 +270,12 @@ from .params import (  # noqa
     param_render,
 )
 
+from .recursion import (  # noqa
+    LimitedRecursionError,
+    recursion_limiting,
+    recursion_limiting_context,
+)
+
 from .resolving import (  # noqa
     Resolvable,
     ResolvableClassNameError,

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/lang/cached/function.py

@@ -15,6 +15,8 @@ TODO:
    - and must be transient?
  - use __transient_dict__ to support common state nuking
  - use __set_name__ ?
+ - on_compute
+ - max_recursion?
 """
 import dataclasses as dc
 import functools
@@ -201,6 +203,9 @@ class _CachedFunction(ta.Generic[T], Abstract):
         except KeyError:
             pass
 
+        def call_value_fn():
+            return self._value_fn(*args, **kwargs)
+
         if self._lock is not None:
             with self._lock:
                 try:
@@ -208,10 +213,10 @@ class _CachedFunction(ta.Generic[T], Abstract):
                 except KeyError:
                     pass
 
-                value = self._value_fn(*args, **kwargs)
+                value = call_value_fn()
 
         else:
-            value = self._value_fn(*args, **kwargs)
+            value = call_value_fn()
 
         self._values[k] = value
         return value

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/lang/casing.py

@@ -78,7 +78,7 @@ class LowCamelCase(StringCasing):
     """fooBarBaz"""
 
     _MATCH_PAT: ta.ClassVar[re.Pattern] = re.compile(r'[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*')
-    _SPLIT_PAT: ta.ClassVar[re.Pattern] = re.compile(r'^[a-z0-9]+')
+    _FIRST_PAT: ta.ClassVar[re.Pattern] = re.compile(r'^[a-z0-9]+')
     _UPPER_PAT: ta.ClassVar[re.Pattern] = re.compile(r'[A-Z][a-z0-9]*')
 
     def match(self, s: str) -> bool:
@@ -88,7 +88,7 @@ class LowCamelCase(StringCasing):
         if not self.match(s):
             raise ImproperStringCasingError(f'Not valid lowCamelCase: {s!r}')
         parts: list[str] = []
-        m0 = self._SPLIT_PAT.match(s)
+        m0 = self._FIRST_PAT.match(s)
         if m0:
             parts.append(m0.group(0))
             start = m0.end()

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/lang/objects.py

@@ -222,3 +222,31 @@ class _AnonObject:
 
 def anon_object(**attrs: ta.Any) -> ta.Any:
     return _AnonObject(**attrs)
+
+
+##
+
+
+class Identity(ta.Generic[T]):
+    def __init__(self, obj: T) -> None:
+        super().__init__()
+
+        self._obj = obj
+
+    def __bool__(self):
+        raise TypeError
+
+    @property
+    def obj(self) -> T:
+        return self._obj
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._obj!r})'
+
+    def __hash__(self) -> int:
+        return id(self._obj)
+
+    def __eq__(self, other):
+        if type(other) is not type(self):
+            return NotImplemented
+        return self._obj is other._obj  # noqa

omlish-0.0.0.dev305/omlish/lang/recursion.py

@@ -0,0 +1,109 @@
+import contextlib
+import dataclasses as dc
+import functools
+import threading
+import typing as ta
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+_LOCK = threading.RLock()
+
+_LOCAL: threading.local
+
+
+def _local() -> threading.local:
+    global _LOCAL
+
+    try:
+        return _LOCAL
+    except NameError:
+        pass
+
+    with _LOCK:
+        try:
+            return _LOCAL
+        except NameError:
+            pass
+
+        _LOCAL = threading.local()
+        return _LOCAL
+
+
+def _depth_map() -> dict[ta.Any, int]:
+    lo = _local()
+    try:
+        return lo.depth_map
+    except AttributeError:
+        dm = lo.depth_map = {}
+        return dm
+
+
+##
+
+
+@dc.dataclass()
+class LimitedRecursionError(RecursionError):
+    key: ta.Any
+    depth: int
+
+
+@contextlib.contextmanager
+def recursion_limiting_context(key: ta.Any, limit: int | None) -> ta.Iterator[int | None]:
+    if limit is None:
+        yield None
+        return
+
+    dm = _depth_map()
+
+    try:
+        pd: int | None = dm[key]
+    except KeyError:
+        pd = None
+    else:
+        if not isinstance(pd, int) and pd > 0:  # type: ignore[operator]
+            raise RuntimeError
+
+    if pd is not None and pd >= limit:
+        raise LimitedRecursionError(key, pd)
+
+    nd = (pd or 0) + 1
+    dm[key] = nd
+
+    try:
+        yield nd
+
+    finally:
+        if dm.get(key) != nd:
+            raise RuntimeError
+
+        if pd is not None:
+            dm[key] = pd
+        else:
+            del dm[key]
+
+
+##
+
+
+def recursion_limiting(limit: int | None) -> ta.Callable[[ta.Callable[P, T]], ta.Callable[P, T]]:
+    def outer(fn):
+        if not callable(fn):
+            raise TypeError(fn)
+
+        if limit is None:
+            return fn
+
+        @functools.wraps(fn)
+        def inner(*args, **kwargs):
+            with recursion_limiting_context(fn, limit):
+                return fn(*args, **kwargs)
+
+        return inner
+
+    return outer

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/marshal/__init__.py

@@ -82,9 +82,9 @@ from .objects.dataclasses import (  # noqa
 )
 
 from .objects.helpers import (  # noqa
-    update_field_metadata,
     update_fields_metadata,
     update_object_metadata,
+    with_field_metadata,
 )
 
 from .objects.marshal import (  # noqa

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/marshal/objects/helpers.py

@@ -11,7 +11,7 @@ T = ta.TypeVar('T')
 ##
 
 
-def update_field_metadata(**kwargs: ta.Any) -> dc.field_modifier:
+def with_field_metadata(**kwargs: ta.Any) -> dc.field_modifier:
     @dc.field_modifier
     def inner(f: dc.Field) -> dc.Field:
         return dc.set_field_metadata(f, {

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/specs/jsonschema/__init__.py

@@ -44,6 +44,10 @@ from .keywords.unknown import (  # noqa
 )
 
 from .keywords.validation import (  # noqa
+    AdditionalProperties,
+    AnyOf,
+    Const,
+    Enum,
     ExclusiveMaximum,
     ExclusiveMinimum,
     Items,
@@ -51,6 +55,7 @@ from .keywords.validation import (  # noqa
     Maximum,
     MinItems,
     Minimum,
+    OneOf,
     Properties,
     Required,
     Type,

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/specs/jsonschema/keywords/base.py

@@ -75,6 +75,16 @@ class Keywords(lang.Final):
 ##
 
 
+@dc.dataclass(frozen=True)
+class AnyKeyword(Keyword, lang.Abstract):
+    v: ta.Any
+
+
+@dc.dataclass(frozen=True)
+class AnyArrayKeyword(Keyword, lang.Abstract):
+    vs: ta.Sequence[ta.Any]
+
+
 @dc.dataclass(frozen=True)
 class BooleanKeyword(Keyword, lang.Abstract):
     b: bool
@@ -91,7 +101,7 @@ class StrKeyword(Keyword, lang.Abstract):
 
 
 @dc.dataclass(frozen=True)
-class StrOrStrsKeyword(Keyword, lang.Abstract):
+class StrOrStrArrayKeyword(Keyword, lang.Abstract):
     ss: str | ta.Sequence[str]
 
 
@@ -100,6 +110,16 @@ class KeywordsKeyword(Keyword, lang.Abstract):
     kw: Keywords
 
 
+@dc.dataclass(frozen=True)
+class KeywordsArrayKeyword(Keyword, lang.Abstract):
+    kws: ta.Sequence[Keywords]
+
+
 @dc.dataclass(frozen=True)
 class StrToKeywordsKeyword(Keyword, lang.Abstract):
     m: ta.Mapping[str, Keywords]
+
+
+@dc.dataclass(frozen=True)
+class BooleanOrKeywordsKeyword(Keyword, lang.Abstract):
+    bk: bool | Keywords

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/specs/jsonschema/keywords/parse.py

@@ -3,14 +3,18 @@ import typing as ta
 from .... import check
 from .... import collections as col
 from .... import lang
+from .base import AnyArrayKeyword
+from .base import AnyKeyword
 from .base import BooleanKeyword
+from .base import BooleanOrKeywordsKeyword
 from .base import Keyword
 from .base import Keywords
+from .base import KeywordsArrayKeyword
 from .base import KeywordsKeyword
 from .base import KnownKeyword
 from .base import NumberKeyword
 from .base import StrKeyword
-from .base import StrOrStrsKeyword
+from .base import StrOrStrArrayKeyword
 from .base import StrToKeywordsKeyword
 from .core import CoreKeyword
 from .format import FormatKeyword
@@ -69,16 +73,28 @@ class KeywordParser:
         self._allow_unknown = allow_unknown
 
     def parse_keyword(self, cls: type[KeywordT], v: ta.Any) -> KeywordT:
-        if issubclass(cls, BooleanKeyword):
+        if issubclass(cls, AnyKeyword):
+            return cls(v)  # type: ignore
+
+        elif issubclass(cls, AnyArrayKeyword):
+            return cls(tuple(check.isinstance(v, ta.Sequence)))  # type: ignore
+
+        elif issubclass(cls, BooleanKeyword):
             return cls(check.isinstance(v, bool))  # type: ignore
 
+        elif issubclass(cls, BooleanOrKeywordsKeyword):
+            if isinstance(v, bool):
+                return cls(v)  # type: ignore
+            else:
+                return cls(self.parse_keywords(v))  # type: ignore
+
         elif issubclass(cls, NumberKeyword):
             return cls(check.isinstance(v, (int, float)))  # type: ignore
 
         elif issubclass(cls, StrKeyword):
             return cls(check.isinstance(v, str))  # type: ignore
 
-        elif issubclass(cls, StrOrStrsKeyword):
+        elif issubclass(cls, StrOrStrArrayKeyword):
             ss: str | ta.Sequence[str]
             if isinstance(v, str):
                 ss = v
@@ -91,6 +107,9 @@ class KeywordParser:
         elif issubclass(cls, KeywordsKeyword):
             return cls(self.parse_keywords(v))  # type: ignore
 
+        elif issubclass(cls, KeywordsArrayKeyword):
+            return cls(tuple(self.parse_keywords(e) for e in v))  # type: ignore
+
         elif issubclass(cls, StrToKeywordsKeyword):
             return cls({k: self.parse_keywords(mv) for k, mv in v.items()})  # type: ignore
 

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/specs/jsonschema/keywords/render.py

@@ -1,12 +1,16 @@
 import typing as ta
 
+from .base import AnyArrayKeyword
+from .base import AnyKeyword
 from .base import BooleanKeyword
+from .base import BooleanOrKeywordsKeyword
 from .base import Keyword
 from .base import Keywords
+from .base import KeywordsArrayKeyword
 from .base import KeywordsKeyword
 from .base import NumberKeyword
 from .base import StrKeyword
-from .base import StrOrStrsKeyword
+from .base import StrOrStrArrayKeyword
 from .base import StrToKeywordsKeyword
 from .unknown import UnknownKeyword
 
@@ -15,16 +19,28 @@ from .unknown import UnknownKeyword
 
 
 def render_keyword(kw: Keyword) -> dict[str, ta.Any]:
-    if isinstance(kw, BooleanKeyword):
+    if isinstance(kw, AnyKeyword):
+        return {kw.tag: kw.v}
+
+    elif isinstance(kw, AnyArrayKeyword):
+        return {kw.tag: kw.vs}
+
+    elif isinstance(kw, BooleanKeyword):
         return {kw.tag: kw.b}
 
+    elif isinstance(kw, BooleanOrKeywordsKeyword):
+        if isinstance(kw.bk, bool):
+            return {kw.tag: kw.bk}
+        else:
+            return {kw.tag: render_keywords(kw.bk)}
+
     elif isinstance(kw, NumberKeyword):
         return {kw.tag: kw.n}
 
     elif isinstance(kw, StrKeyword):
         return {kw.tag: kw.s}
 
-    elif isinstance(kw, StrOrStrsKeyword):
+    elif isinstance(kw, StrOrStrArrayKeyword):
         if isinstance(kw.ss, str):
             return {kw.tag: kw.ss}
         else:
@@ -33,6 +49,9 @@ def render_keyword(kw: Keyword) -> dict[str, ta.Any]:
     elif isinstance(kw, KeywordsKeyword):
         return {kw.tag: render_keywords(kw.kw)}
 
+    elif isinstance(kw, KeywordsArrayKeyword):
+        return {kw.tag: [render_keywords(c) for c in kw.kws]}
+
     elif isinstance(kw, StrToKeywordsKeyword):
         return {kw.tag: {k: render_keywords(v) for k, v in kw.m.items()}}
 

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/specs/jsonschema/keywords/validation.py

@@ -1,9 +1,13 @@
 from .... import lang
+from .base import AnyArrayKeyword
+from .base import AnyKeyword
 from .base import BooleanKeyword
+from .base import BooleanOrKeywordsKeyword
+from .base import KeywordsArrayKeyword
 from .base import KeywordsKeyword
 from .base import KnownKeyword
 from .base import NumberKeyword
-from .base import StrOrStrsKeyword
+from .base import StrOrStrArrayKeyword
 from .base import StrToKeywordsKeyword
 
 
@@ -17,7 +21,15 @@ class ValidationKeyword(KnownKeyword, lang.Abstract, lang.Sealed):
 ##
 
 
-class Type(StrOrStrsKeyword, ValidationKeyword, lang.Final, tag='type'):
+class Type(StrOrStrArrayKeyword, ValidationKeyword, lang.Final, tag='type'):
+    pass
+
+
+class Const(AnyKeyword, ValidationKeyword, lang.Final, tag='const'):
+    pass
+
+
+class Enum(AnyArrayKeyword, ValidationKeyword, lang.Final, tag='enum'):
     pass
 
 
@@ -25,7 +37,7 @@ class Items(KeywordsKeyword, ValidationKeyword, lang.Final, tag='items'):
     pass
 
 
-class Required(StrOrStrsKeyword, ValidationKeyword, lang.Final, tag='required'):
+class Required(StrOrStrArrayKeyword, ValidationKeyword, lang.Final, tag='required'):
     pass
 
 
@@ -33,6 +45,10 @@ class Properties(StrToKeywordsKeyword, ValidationKeyword, lang.Final, tag='prope
     pass
 
 
+class AdditionalProperties(BooleanOrKeywordsKeyword, ValidationKeyword, lang.Final, tag='additionalProperties'):
+    pass
+
+
 ##
 
 
@@ -65,3 +81,14 @@ class Minimum(NumberKeyword, ValidationKeyword, lang.Final, tag='minimum'):
 
 class ExclusiveMinimum(NumberKeyword, ValidationKeyword, lang.Final, tag='exclusiveMinimum'):
     pass
+
+
+#
+
+
+class AnyOf(KeywordsArrayKeyword, ValidationKeyword, lang.Final, tag='anyOf'):
+    pass
+
+
+class OneOf(KeywordsArrayKeyword, ValidationKeyword, lang.Final, tag='oneOf'):
+    pass

omlish-0.0.0.dev305/omlish/specs/jsonschema/schemas/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2022 JSON Schema Specification Authors
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+   disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/sql/api/__init__.py

@@ -35,9 +35,16 @@ from .errors import (  # noqa
 )
 
 from .funcs import (  # noqa
+    exec,  # noqa
+
     query,
     query_all,
-    exec,  # noqa
+    query_first,
+    query_opt_first,
+    query_one,
+    query_opt_one,
+    query_scalar,
+    query_maybe_scalar,
 )
 
 from .queries import (  # noqa

{omlish-0.0.0.dev303 → omlish-0.0.0.dev305}/omlish/sql/api/base.py

@@ -30,7 +30,7 @@ class Querier(ContextCloser, lang.Abstract):
 ##
 
 
-class Rows(ContextCloser, lang.Abstract):
+class Rows(ContextCloser, ta.Iterator[Row], lang.Abstract):
     @property
     @abc.abstractmethod
     def columns(self) -> Columns: