omlish 0.0.0.dev304__py3-none-any.whl → 0.0.0.dev306__py3-none-any.whl

omlish/formats/edn/values.py

@@ -0,0 +1,162 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ... import lang
+from ...lite.dataclasses import dataclass_cache_hash
+
+
+##
+
+
+_DEBUG = __debug__
+# _DEBUG = True
+
+
+@dc.dataclass(frozen=True)
+class Value(lang.Abstract, lang.Sealed):
+    pass
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class Scalar(Value, lang.Abstract):
+    pass
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Keyword(Scalar, lang.Final):
+    s: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.s!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.s, str)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Char(Scalar, lang.Final):
+    c: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.c!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.c, str)
+            check.equal(len(self.c), 1)
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Symbol(Scalar, lang.Final):
+    n: str
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.n!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.non_empty_str(self.n)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class Collection(Value, lang.Abstract):
+    pass
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class List(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any]) -> 'List':
+        return cls(tuple(items))
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Vector(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any]) -> 'Vector':
+        return cls(tuple(items))
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Set(Collection, lang.Final):
+    items: ta.Sequence[ta.Any]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Any]) -> 'Set':
+        return cls(tuple(items))
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class Map(Collection, lang.Final):
+    items: ta.Sequence[tuple[ta.Any, ta.Any]]
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.items!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.isinstance(self.items, tuple)
+            for t in self.items:
+                check.isinstance(t, tuple)
+                check.equal(len(t), 2)
+
+    @classmethod
+    def new(cls, items: ta.Iterable[ta.Iterable[ta.Any]]) -> 'Map':
+        return cls(tuple((k, v) for k, v in items))
+
+
+#
+
+
+@dataclass_cache_hash()
+@dc.dataclass(frozen=True)
+class TaggedVal(Value, lang.Final):
+    t: str
+    v: ta.Any
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.t!r}, {self.v!r})'
+
+    if _DEBUG:
+        def __post_init__(self) -> None:
+            check.non_empty_str(self.t)

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/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/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/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/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/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/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/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/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:

omlish/sql/api/funcs.py

@@ -1,5 +1,7 @@
 import typing as ta
 
+from ... import check
+from ... import lang
 from .asquery import as_query
 from .base import Querier
 from .base import Rows
@@ -10,6 +12,25 @@ from .rows import Row
 ##
 
 
+def exec(  # noqa
+        querier: Querier,
+        obj: ta.Any,
+        *args: ta.Any,
+) -> None:
+    q = as_query(
+        obj,
+        *args,
+        mode=QueryMode.EXEC,
+        querier=querier,
+    )
+
+    with querier.query(q):
+        pass
+
+
+##
+
+
 def query(
         querier: Querier,
         obj: ta.Any,
@@ -37,20 +58,58 @@ def query_all(
         return list(rows)
 
 
-##
+def query_first(
+        querier: Querier,
+        obj: ta.Any,
+        *args: ta.Any,
+) -> Row:
+    with query(querier, obj, *args) as rows:
+        return next(rows)
 
 
-def exec(  # noqa
+def query_opt_first(
         querier: Querier,
         obj: ta.Any,
         *args: ta.Any,
-) -> None:
-    q = as_query(
-        obj,
-        *args,
-        mode=QueryMode.EXEC,
-        querier=querier,
-    )
+) -> Row | None:
+    with query(querier, obj, *args) as rows:
+        return next(rows, None)
 
-    with querier.query(q):
-        pass
+
+def query_one(
+        querier: Querier,
+        obj: ta.Any,
+        *args: ta.Any,
+) -> Row:
+    with query(querier, obj, *args) as rows:
+        return check.single(rows)
+
+
+def query_opt_one(
+        querier: Querier,
+        obj: ta.Any,
+        *args: ta.Any,
+) -> Row | None:
+    with query(querier, obj, *args) as rows:
+        return check.opt_single(rows)
+
+
+def query_scalar(
+        querier: Querier,
+        obj: ta.Any,
+        *args: ta.Any,
+) -> ta.Any:
+    row = query_one(querier, obj, *args)
+    return check.single(row.values)
+
+
+def query_maybe_scalar(
+        querier: Querier,
+        obj: ta.Any,
+        *args: ta.Any,
+) -> lang.Maybe[ta.Any]:
+    row = query_opt_one(querier, obj, *args)
+    if row is not None:
+        return lang.just(check.single(row.values))
+    else:
+        return lang.empty()

omlish/sql/qualifiedname.py

@@ -1,23 +1,31 @@
 import collections.abc
-import dataclasses as dc
 import typing as ta
 
+from .. import dataclasses as dc
+from .. import lang
+
 
 ##
 
 
+def coerce_parts(parts: ta.Sequence[str]) -> tuple[str, ...]:
+    if not parts:
+        raise ValueError
+    if isinstance(parts, str):
+        raise TypeError(parts)
+    if not isinstance(parts, tuple):
+        parts = tuple(parts)
+    if not all(parts) and all(isinstance(p, str) for p in parts):
+        raise ValueError(parts)
+    return parts
+
+
+#
+
+
 @dc.dataclass(frozen=True)
-class QualifiedName(ta.Sequence[str]):
-    parts: ta.Sequence[str]
-
-    def __post_init__(self) -> None:
-        if not (
-                self.parts and
-                not isinstance(self.parts, str) and
-                all(self.parts) and
-                all(isinstance(p, str) for p in self.parts)
-        ):
-            raise ValueError(self)
+class QualifiedName(ta.Sequence[str], lang.Final):
+    parts: ta.Sequence[str] = dc.field() | dc.with_extra_field_params(coerce=coerce_parts)
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}([{", ".join(map(repr, self.parts))}])'

omlish/sql/queries/__init__.py

@@ -1,5 +1,6 @@
 from .base import (  # noqa
     Builder,
+    HasQn,
     Node,
     NodeComparisonTypeError,
     Value,
@@ -56,6 +57,8 @@ from .params import (  # noqa
 from .relations import (  # noqa
     CanRelation,
     CanTable,
+    Join,
+    JoinKind,
     Relation,
     RelationBuilder,
     Table,

omlish/sql/queries/base.py

@@ -1,8 +1,10 @@
+import abc
 import types
 import typing as ta
 
 from ... import dataclasses as dc
 from ... import lang
+from ..qualifiedname import QualifiedName
 
 
 ##
@@ -45,6 +47,10 @@ class Node(
     def __ne__(self, other) -> ta.NoReturn:
         raise NodeComparisonTypeError(type(self))
 
+    @ta.final
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError
+
     #
 
     @dc.dataclass(frozen=True)
@@ -130,3 +136,13 @@ class Node(
 
 class Builder(lang.Abstract):
     pass
+
+
+##
+
+
+class HasQn(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def qn(self) -> QualifiedName:
+        raise NotImplementedError

omlish/sql/queries/idents.py

@@ -1,9 +1,16 @@
+"""
+TODO:
+ - clamp down on as_ident / CanIdent - no strs allowed
+"""
 import abc
 import functools
 import typing as ta
 
+from ... import cached
 from ... import lang
+from ..qualifiedname import QualifiedName
 from .base import Builder
+from .base import HasQn
 from .base import Node
 
 
@@ -17,9 +24,13 @@ class IdentLike(abc.ABC):  # noqa
 ##
 
 
-class Ident(Node, IdentLike, lang.Final):
+class Ident(Node, IdentLike, HasQn, lang.Final):
     s: str
 
+    @cached.property
+    def qn(self) -> QualifiedName:
+        return QualifiedName((self.s,))
+
 
 ##
 

omlish/sql/queries/names.py

@@ -2,9 +2,12 @@ import abc
 import functools
 import typing as ta
 
+from ... import cached
 from ... import check
 from ... import dataclasses as dc
 from ... import lang
+from ..qualifiedname import QualifiedName
+from .base import HasQn
 from .base import Node
 from .idents import CanIdent
 from .idents import Ident
@@ -27,9 +30,13 @@ def _coerce_name_parts(o: ta.Iterable[Ident]) -> ta.Sequence[Ident]:
     return check.not_empty(tuple(check.isinstance(e, Ident) for e in o))
 
 
-class Name(Node, NameLike, lang.Final):
+class Name(Node, NameLike, HasQn, lang.Final):
     ps: ta.Sequence[Ident] = dc.xfield(coerce=_coerce_name_parts)
 
+    @cached.property
+    def qn(self) -> QualifiedName:
+        return QualifiedName(tuple(p.s for p in self.ps))
+
 
 ##