omlish 0.0.0.dev133__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/reflect/types.py

@@ -7,6 +7,7 @@ TODO:
  - cache this shit, esp generic_mro shit
   - cache __hash__ in Generic/Union
 """
+import abc
 import dataclasses as dc
 import types
 import typing as ta
@@ -17,11 +18,12 @@ _NoneType = types.NoneType  # type: ignore
 _NONE_TYPE_FROZENSET: frozenset['Type'] = frozenset([_NoneType])
 
 
-_GenericAlias = ta._GenericAlias  # type: ignore  # noqa
+_AnnotatedAlias = ta._AnnotatedAlias  # type: ignore  # noqa
 _CallableGenericAlias = ta._CallableGenericAlias  # type: ignore  # noqa
+_GenericAlias = ta._GenericAlias  # type: ignore  # noqa
+_LiteralGenericAlias = ta._LiteralGenericAlias  # type: ignore  # noqa
 _SpecialGenericAlias = ta._SpecialGenericAlias  # type: ignore  # noqa
 _UnionGenericAlias = ta._UnionGenericAlias   # type: ignore  # noqa
-_AnnotatedAlias = ta._AnnotatedAlias  # type: ignore  # noqa
 
 
 ##
@@ -116,19 +118,29 @@ def get_newtype_supertype(obj: ta.Any) -> ta.Any:
 ##
 
 
-Type: ta.TypeAlias = ta.Union[
+class TypeInfo(abc.ABC):  # noqa
+    pass
+
+
+Type: ta.TypeAlias = ta.Union[  # noqa
     type,
     ta.TypeVar,
-    'Union',
-    'Generic',
-    'NewType',
-    'Annotated',
-    'Any',
+    TypeInfo,
 ]
 
 
+TYPES: tuple[type, ...] = (
+    type,
+    ta.TypeVar,
+    TypeInfo,
+)
+
+
+##
+
+
 @dc.dataclass(frozen=True)
-class Union:
+class Union(TypeInfo):
     args: frozenset[Type]
 
     @property
@@ -144,8 +156,11 @@ class Union:
         return Union(rem)
 
 
+#
+
+
 @dc.dataclass(frozen=True)
-class Generic:
+class Generic(TypeInfo):
     cls: type
     args: tuple[Type, ...]                                                # map[int, V] = (int, V) | map[T, T] = (T, T)
 
@@ -167,39 +182,51 @@ class Generic:
         )
 
 
+#
+
+
 @dc.dataclass(frozen=True)
-class NewType:
+class NewType(TypeInfo):
     obj: ta.Any
     ty: Type
 
 
+#
+
+
 @dc.dataclass(frozen=True)
-class Annotated:
+class Annotated(TypeInfo):
     ty: Type
     md: ta.Sequence[ta.Any]
 
     obj: ta.Any = dc.field(compare=False, repr=False)
 
 
-class Any:
+#
+
+
+@dc.dataclass(frozen=True)
+class Literal(TypeInfo):
+    args: tuple[ta.Any, ...]
+
+    obj: ta.Any = dc.field(compare=False, repr=False)
+
+
+#
+
+
+class Any(TypeInfo):
     pass
 
 
 ANY = Any()
 
 
-TYPES: tuple[type, ...] = (
-    type,
-    ta.TypeVar,
-    Union,
-    Generic,
-    NewType,
-    Annotated,
-    Any,
-)
+##
 
 
-##
+class ReflectTypeError(TypeError):
+    pass
 
 
 class Reflector:
@@ -212,57 +239,80 @@ class Reflector:
 
         self._override = override
 
+    #
+
     def is_type(self, obj: ta.Any) -> bool:
-        if isinstance(obj, (Union, Generic, ta.TypeVar, NewType, Any)):  # noqa
+        try:
+            self._type(obj, check_only=True)
+        except ReflectTypeError:
+            return False
+        else:
             return True
 
-        oty = type(obj)
-
-        return (
-                oty is _UnionGenericAlias or oty is types.UnionType or  # noqa
-
-                isinstance(obj, ta.NewType) or  # noqa
-
-                (
-                    is_simple_generic_alias_type(oty) or
-                    oty is _CallableGenericAlias
-                ) or
+    def type(self, obj: ta.Any) -> Type:
+        if (ty := self._type(obj, check_only=False)) is None:
+            raise RuntimeError(obj)
+        return ty
 
-                isinstance(obj, type) or
+    #
 
-                isinstance(obj, _SpecialGenericAlias)
-        )
+    def _type(self, obj: ta.Any, *, check_only: bool) -> Type | None:
+        ##
+        # Overrides beat everything
 
-    def type(self, obj: ta.Any) -> Type:
         if self._override is not None:
             if (ovr := self._override(obj)) is not None:
                 return ovr
 
+        ##
+        # Any
+
         if obj is ta.Any:
             return ANY
 
-        if isinstance(obj, (Union, Generic, ta.TypeVar, NewType, Any)):  # noqa
+        ##
+        # Already a Type?
+
+        if isinstance(obj, (ta.TypeVar, TypeInfo)):  # noqa
             return obj
 
         oty = type(obj)
 
+        ##
+        # Union
+
         if oty is _UnionGenericAlias or oty is types.UnionType:
+            if check_only:
+                return None
+
             return Union(frozenset(self.type(a) for a in ta.get_args(obj)))
 
+        ##
+        # NewType
+
         if isinstance(obj, ta.NewType):  # noqa
+            if check_only:
+                return None
+
             return NewType(obj, get_newtype_supertype(obj))
 
+        ##
+        # Simple Generic
+
         if (
                 is_simple_generic_alias_type(oty) or
                 oty is _CallableGenericAlias
         ):
+            if check_only:
+                return None
+
             origin = ta.get_origin(obj)
             args = ta.get_args(obj)
 
             if oty is _CallableGenericAlias:
                 p, r = args
                 if p is Ellipsis or isinstance(p, ta.ParamSpec):
-                    raise TypeError(f'Callable argument not yet supported for {obj=}')
+                    raise ReflectTypeError(f'Callable argument not yet supported for {obj=}')
                 args = (*p, r)
                 params = _KNOWN_SPECIAL_TYPE_VARS[:len(args)]
 
@@ -276,7 +326,7 @@ class Reflector:
                 params = get_params(origin)
 
             if len(args) != len(params):
-                raise TypeError(f'Mismatched {args=} and {params=} for {obj=}')
+                raise ReflectTypeError(f'Mismatched {args=} and {params=} for {obj=}')
 
             return Generic(
                 origin,
@@ -285,7 +335,13 @@ class Reflector:
                 obj,
             )
 
+        ##
+        # Full Generic
+
         if isinstance(obj, type):
+            if check_only:
+                return None
+
             if issubclass(obj, ta.Generic):  # type: ignore
                 params = get_params(obj)
                 if params:
@@ -295,12 +351,20 @@ class Reflector:
                         params,
                         obj,
                     )
+
             return obj
 
+        ##
+        # Special Generic
+
         if isinstance(obj, _SpecialGenericAlias):
             if (ks := _KNOWN_SPECIALS_BY_ALIAS.get(obj)) is not None:
+                if check_only:
+                    return None
+
                 if (np := ks.nparams) < 0:
-                    raise TypeError(obj)
+                    raise ReflectTypeError(obj)
+
                 params = _KNOWN_SPECIAL_TYPE_VARS[:np]
                 return Generic(
                     ks.origin,
@@ -309,11 +373,29 @@ class Reflector:
                     obj,
                 )
 
+        ##
+        # Annotated
+
         if isinstance(obj, _AnnotatedAlias):
+            if check_only:
+                return None
+
             o = ta.get_args(obj)[0]
             return Annotated(self.type(o), md=obj.__metadata__, obj=obj)
 
-        raise TypeError(obj)
+        ##
+        # Literal
+
+        if isinstance(obj, _LiteralGenericAlias):
+            if check_only:
+                return None
+
+            return Literal(ta.get_args(obj), obj=obj)
+
+        ##
+        # Failure
+
+        raise ReflectTypeError(obj)
 
 
 DEFAULT_REFLECTOR = Reflector()

omlish/secrets/pwhash.py

@@ -28,7 +28,7 @@ import secrets
 
 
 SALT_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
-DEFAULT_PBKDF2_ITERATIONS = 600000
+DEFAULT_PBKDF2_ITERATIONS = 600_000
 
 
 def gen_salt(length: int) -> str:

omlish/secrets/subprocesses.py

@@ -32,7 +32,9 @@ def pipe_fd_subprocess_file_input(buf: bytes) -> ta.Iterator[SubprocessFileInput
     try:
         if hasattr(fcntl, 'F_SETPIPE_SZ'):
             fcntl.fcntl(wfd, fcntl.F_SETPIPE_SZ, max(len(buf), 0x1000))
-        os.write(wfd, buf)
+        n = os.write(wfd, buf)
+        if n != len(buf):
+            raise OSError(f'Failed to write data to pipe: {n=} {len(buf)=}')
         os.close(wfd)
         closed_wfd = True
         yield SubprocessFileInput(f'/dev/fd/{rfd}', [rfd])

omlish/specs/jsonrpc/marshal.py

@@ -4,8 +4,8 @@ from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from ... import marshal as msh
-from ... import matchfns as mfs
 from ... import reflect as rfl
+from ...funcs import match as mfs
 from .types import NotSpecified
 
 

omlish/specs/openapi/marshal.py

@@ -4,8 +4,8 @@ from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from ... import marshal as msh
-from ... import matchfns as mfs
 from ... import reflect as rfl
+from ...funcs import match as mfs
 from .openapi import Reference
 
 

omlish/sql/alchemy/asyncs.py

@@ -9,7 +9,7 @@ import typing as ta
 import sqlalchemy as sa
 import sqlalchemy.ext.asyncio as saa
 
-from ... import asyncs as au
+from ...asyncs import all as au
 
 
 T = ta.TypeVar('T')

omlish/sql/queries/__init__.py

@@ -22,13 +22,13 @@ from .exprs import (  # noqa
     ExprBuilder,
     Literal,
     NameExpr,
-    Param,
 )
 
 from .idents import (  # noqa
     CanIdent,
     Ident,
     IdentBuilder,
+    IdentLike,
 )
 
 from .multi import (  # noqa
@@ -41,12 +41,20 @@ from .names import (  # noqa
     CanName,
     Name,
     NameBuilder,
+    NameLike,
 )
 
 from .ops import (  # noqa
     OpKind,
 )
 
+from .params import (  # noqa
+    CanParam,
+    Param,
+    ParamBuilder,
+    as_param,
+)
+
 from .relations import (  # noqa
     CanRelation,
     CanTable,

omlish/sql/queries/building.py

@@ -5,6 +5,7 @@ from .idents import IdentBuilder
 from .inserts import InsertBuilder
 from .multi import MultiBuilder
 from .names import NameBuilder
+from .params import ParamBuilder
 from .relations import RelationBuilder
 from .selects import SelectBuilder
 from .stmts import StmtBuilder
@@ -23,6 +24,8 @@ class StdBuilder(
 
     RelationBuilder,
 
+    ParamBuilder,
+
     NameBuilder,
     IdentBuilder,
 

omlish/sql/queries/exprs.py

@@ -8,10 +8,11 @@ import typing as ta
 from ... import lang
 from .base import Node
 from .base import Value
-from .idents import Ident
+from .idents import IdentLike
 from .names import CanName
 from .names import Name
 from .names import NameBuilder
+from .names import NameLike
 
 
 ##
@@ -21,30 +22,21 @@ class Expr(Node, lang.Abstract):
     pass
 
 
+#
+
+
 class Literal(Expr, lang.Final):
     v: Value
 
 
-class NameExpr(Expr, lang.Final):
-    n: Name
+#
 
 
-class Param(Expr, lang.Final):
-    n: str | None = None
+class NameExpr(Expr, lang.Final):
+    n: Name
 
-    def __repr__(self) -> str:
-        if self.n is not None:
-            return f'{self.__class__.__name__}({self.n!r})'
-        else:
-            return f'{self.__class__.__name__}(@{hex(id(self))[2:]})'
 
-    def __eq__(self, other):
-        if not isinstance(other, Param):
-            return False
-        if self.n is None and other.n is None:
-            return self is other
-        else:
-            return self.n == other.n
+##
 
 
 CanLiteral: ta.TypeAlias = Literal | Value
@@ -69,7 +61,7 @@ class ExprBuilder(NameBuilder):
     def expr(self, o: CanExpr) -> Expr:
         if isinstance(o, Expr):
             return o
-        elif isinstance(o, (Name, Ident)):
+        elif isinstance(o, (NameLike, IdentLike)):
             return NameExpr(self.name(o))
         else:
             return self.literal(o)
@@ -77,12 +69,3 @@ class ExprBuilder(NameBuilder):
     @ta.final
     def e(self, o: CanExpr) -> Expr:
         return self.expr(o)
-
-    #
-
-    def param(self, n: str | None = None) -> Param:
-        return Param(n)
-
-    @ta.final
-    def p(self, n: str | None = None) -> Param:
-        return self.param(n)

omlish/sql/queries/idents.py

@@ -1,3 +1,5 @@
+import abc
+import functools
 import typing as ta
 
 from ... import lang
@@ -8,22 +10,58 @@ from .base import Node
 ##
 
 
-class Ident(Node, lang.Final):
+class IdentLike(abc.ABC):  # noqa
+    pass
+
+
+##
+
+
+class Ident(Node, IdentLike, lang.Final):
     s: str
 
 
-CanIdent: ta.TypeAlias = Ident | str
+##
+
+
+@functools.singledispatch
+def as_ident(o: ta.Any) -> Ident:
+    raise TypeError(o)
+
+
+@as_ident.register
+def _(i: Ident) -> Ident:
+    return i
+
+
+@as_ident.register
+def _(s: str) -> Ident:
+    return Ident(s)
+
+
+##
+
+
+CanIdent: ta.TypeAlias = IdentLike | Ident | str
+
+
+class IdentAccessor(lang.Final):
+    def __getattr__(self, s: str) -> Ident:
+        return Ident(s)
+
+    def __call__(self, o: CanIdent) -> Ident:
+        return as_ident(o)
+
+
+##
 
 
 class IdentBuilder(Builder):
+    @ta.final
     def ident(self, o: CanIdent) -> Ident:
-        if isinstance(o, Ident):
-            return o
-        elif isinstance(o, str):
-            return Ident(o)
-        else:
-            raise TypeError(o)
+        return as_ident(o)
 
     @ta.final
-    def i(self, o: CanIdent) -> Ident:
-        return self.ident(o)
+    @property
+    def i(self) -> IdentAccessor:
+        return IdentAccessor()

omlish/sql/queries/names.py

@@ -1,34 +1,101 @@
+import abc
+import functools
 import typing as ta
 
+from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from .base import Node
 from .idents import CanIdent
 from .idents import Ident
 from .idents import IdentBuilder
+from .idents import as_ident
 
 
 ##
 
 
-class Name(Node, lang.Final):
-    ps: ta.Sequence[Ident] = dc.xfield(coerce=tuple)
+class NameLike(abc.ABC):  # noqa
+    pass
 
 
-CanName: ta.TypeAlias = Name | CanIdent | ta.Sequence[CanIdent]
+##
+
+
+def _coerce_name_parts(o: ta.Iterable[Ident]) -> ta.Sequence[Ident]:
+    check.not_isinstance(o, str)
+    return check.not_empty(tuple(check.isinstance(e, Ident) for e in o))
+
+
+class Name(Node, NameLike, lang.Final):
+    ps: ta.Sequence[Ident] = dc.xfield(coerce=_coerce_name_parts)
+
+
+##
+
+
+@functools.singledispatch
+def as_name(o: ta.Any) -> Name:
+    if isinstance(o, ta.Sequence):
+        return Name([as_ident(p) for p in o])
+    else:
+        raise TypeError(o)
+
+
+@as_name.register
+def _(n: Name) -> Name:
+    return n
+
+
+@as_name.register
+def _(o: Ident | str) -> Name:
+    return Name([as_ident(o)])
+
+
+##
+
+
+CanName: ta.TypeAlias = ta.Union[
+    NameLike,
+    Name,
+    CanIdent,
+    ta.Sequence[CanIdent],
+    'NameAccessor',
+]
+
+
+class NameAccessor(NameLike, lang.Final):
+    def __init__(self, ps: tuple[str, ...] = ()) -> None:
+        super().__init__()
+        self.__query_name_parts__ = ps
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.__query_name_parts__!r})'
+
+    def __getattr__(self, s: str) -> 'NameAccessor':
+        return NameAccessor((*self.__query_name_parts__, s))
+
+    def __call__(self, o: CanName) -> Name:
+        n = as_name(o)
+        if (ps := self.__query_name_parts__):
+            n = Name(tuple(*tuple(Ident(p) for p in ps), *n.ps))  # type: ignore[arg-type]
+        return n
+
+
+@as_name.register
+def _(a: NameAccessor) -> Name:
+    return Name(tuple(Ident(p) for p in a.__query_name_parts__))
+
+
+##
 
 
 class NameBuilder(IdentBuilder):
+    @ta.final
     def name(self, o: CanName) -> Name:
-        if isinstance(o, Name):
-            return o
-        elif isinstance(o, (Ident, str)):
-            return Name([self.ident(o)])
-        elif isinstance(o, ta.Sequence):
-            return Name([self.ident(p) for p in o])
-        else:
-            raise TypeError(o)
+        return as_name(o)
 
     @ta.final
-    def n(self, o: CanName) -> Name:
-        return self.name(o)
+    @property
+    def n(self) -> NameAccessor:
+        return NameAccessor()