omlish 0.0.0.dev166__tar.gz → 0.0.0.dev168__tar.gz

{omlish-0.0.0.dev166/omlish.egg-info → omlish-0.0.0.dev168}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev166
+Version: 0.0.0.dev168
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev166'
-__revision__ = 'e832ee32347c3f4c51e8ead2186def228e3aac1c'
+__version__ = '0.0.0.dev168'
+__revision__ = 'ecfbedaaef82716f605534252d3eabcc71b2f5c6'
 
 
 #

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168}/omlish/lite/check.py

@@ -2,6 +2,8 @@
 """
 TODO:
  - def maybe(v: lang.Maybe[T])
+ - def not_ ?
+ - ** class @dataclass Raise - user message should be able to be an exception type or instance or factory
 """
 import collections
 import threading

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168}/omlish/lite/strings.py

@@ -21,6 +21,37 @@ def snake_case(name: str) -> str:
 ##
 
 
+def strip_with_newline(s: str) -> str:
+    if not s:
+        return ''
+    return s.strip() + '\n'
+
+
+@ta.overload
+def split_keep_delimiter(s: str, d: str) -> str:
+    ...
+
+
+@ta.overload
+def split_keep_delimiter(s: bytes, d: bytes) -> bytes:
+    ...
+
+
+def split_keep_delimiter(s, d):
+    ps = []
+    i = 0
+    while i < len(s):
+        if (n := s.find(d, i)) < i:
+            ps.append(s[i:])
+            break
+        ps.append(s[i:n + 1])
+        i = n + 1
+    return ps
+
+
+##
+
+
 def is_dunder(name: str) -> bool:
     return (
         name[:2] == name[-2:] == '__' and

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168}/omlish/os/atomics.py

@@ -122,7 +122,7 @@ class AtomicPathSwapping(abc.ABC):
 ##
 
 
-class OsRenameAtomicPathSwap(AtomicPathSwap):
+class OsReplaceAtomicPathSwap(AtomicPathSwap):
     def __init__(
             self,
             kind: AtomicPathSwapKind,
@@ -150,7 +150,7 @@ class OsRenameAtomicPathSwap(AtomicPathSwap):
         return self._tmp_path
 
     def _commit(self) -> None:
-        os.rename(self._tmp_path, self._dst_path)
+        os.replace(self._tmp_path, self._dst_path)
 
     def _abort(self) -> None:
         shutil.rmtree(self._tmp_path, ignore_errors=True)
@@ -197,7 +197,7 @@ class TempDirAtomicPathSwapping(AtomicPathSwapping):
         else:
             raise TypeError(kind)
 
-        return OsRenameAtomicPathSwap(
+        return OsReplaceAtomicPathSwap(
             kind,
             dst_path,
             tmp_path,

omlish-0.0.0.dev168/omlish/os/paths.py

@@ -0,0 +1,36 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import os.path
+import typing as ta
+
+
+def abs_real_path(p: str) -> str:
+    return os.path.abspath(os.path.realpath(p))
+
+
+def is_path_in_dir(base_dir: str, target_path: str) -> bool:
+    base_dir = abs_real_path(base_dir)
+    target_path = abs_real_path(target_path)
+
+    return target_path.startswith(base_dir + os.path.sep)
+
+
+def relative_symlink(
+        src: str,
+        dst: str,
+        *,
+        target_is_directory: bool = False,
+        dir_fd: ta.Optional[int] = None,
+        make_dirs: bool = False,
+        **kwargs: ta.Any,
+) -> None:
+    if make_dirs:
+        os.makedirs(os.path.dirname(dst), exist_ok=True)
+
+    os.symlink(
+        os.path.relpath(src, os.path.dirname(dst)),
+        dst,
+        target_is_directory=target_is_directory,
+        dir_fd=dir_fd,
+        **kwargs,
+    )

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168}/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-0.0.0.dev166 → omlish-0.0.0.dev168}/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-0.0.0.dev166 → omlish-0.0.0.dev168}/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-0.0.0.dev168/omlish/sql/queries/idents.py

@@ -0,0 +1,67 @@
+import abc
+import functools
+import typing as ta
+
+from ... import lang
+from .base import Builder
+from .base import Node
+
+
+##
+
+
+class IdentLike(abc.ABC):  # noqa
+    pass
+
+
+##
+
+
+class Ident(Node, IdentLike, lang.Final):
+    s: 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:
+        return as_ident(o)
+
+    @ta.final
+    @property
+    def i(self) -> IdentAccessor:
+        return IdentAccessor()

omlish-0.0.0.dev168/omlish/sql/queries/names.py

@@ -0,0 +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 NameLike(abc.ABC):  # noqa
+    pass
+
+
+##
+
+
+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:
+        return as_name(o)
+
+    @ta.final
+    @property
+    def n(self) -> NameAccessor:
+        return NameAccessor()

omlish-0.0.0.dev168/omlish/sql/queries/params.py

@@ -0,0 +1,64 @@
+import typing as ta
+
+from ... import lang
+from .base import Builder
+from .exprs import Expr
+
+
+##
+
+
+class Param(Expr, lang.Final):
+    n: str | None = None
+
+    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
+
+
+##
+
+
+CanParam: ta.TypeAlias = Param | str | None
+
+
+def as_param(o: CanParam = None) -> Param:
+    if isinstance(o, Param):
+        return o
+    else:
+        return Param(o)
+
+
+##
+
+
+class ParamAccessor(lang.Final):
+    def __getattr__(self, s: str) -> Param:
+        return Param(s)
+
+    def __call__(self, o: CanParam = None) -> Param:
+        return as_param(o)
+
+
+##
+
+
+class ParamBuilder(Builder):
+    @ta.final
+    def param(self, o: CanParam = None) -> Param:
+        return as_param(o)
+
+    @ta.final
+    @property
+    def p(self) -> ParamAccessor:
+        return ParamAccessor()

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168}/omlish/sql/queries/rendering.py

@@ -29,13 +29,13 @@ from .binary import BinaryOp
 from .binary import BinaryOps
 from .exprs import Literal
 from .exprs import NameExpr
-from .exprs import Param
 from .idents import Ident
 from .inserts import Insert
 from .inserts import Values
 from .multi import Multi
 from .multi import MultiKind
 from .names import Name
+from .params import Param
 from .relations import Table
 from .selects import Select
 from .selects import SelectItem

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev166
+Version: 0.0.0.dev168
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168}/omlish.egg-info/SOURCES.txt

@@ -448,6 +448,7 @@ omlish/os/deathsig.py
 omlish/os/files.py
 omlish/os/journald.py
 omlish/os/linux.py
+omlish/os/paths.py
 omlish/os/pidfile.py
 omlish/os/sizes.py
 omlish/reflect/__init__.py
@@ -527,6 +528,7 @@ omlish/sql/queries/marshal.py
 omlish/sql/queries/multi.py
 omlish/sql/queries/names.py
 omlish/sql/queries/ops.py
+omlish/sql/queries/params.py
 omlish/sql/queries/relations.py
 omlish/sql/queries/rendering.py
 omlish/sql/queries/selects.py

{omlish-0.0.0.dev166 → omlish-0.0.0.dev168}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev166'
+version = '0.0.0.dev168'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev166/omlish/sql/queries/idents.py

@@ -1,29 +0,0 @@
-import typing as ta
-
-from ... import lang
-from .base import Builder
-from .base import Node
-
-
-##
-
-
-class Ident(Node, lang.Final):
-    s: str
-
-
-CanIdent: ta.TypeAlias = Ident | str
-
-
-class IdentBuilder(Builder):
-    def ident(self, o: CanIdent) -> Ident:
-        if isinstance(o, Ident):
-            return o
-        elif isinstance(o, str):
-            return Ident(o)
-        else:
-            raise TypeError(o)
-
-    @ta.final
-    def i(self, o: CanIdent) -> Ident:
-        return self.ident(o)

omlish-0.0.0.dev166/omlish/sql/queries/names.py

@@ -1,34 +0,0 @@
-import typing as ta
-
-from ... import dataclasses as dc
-from ... import lang
-from .base import Node
-from .idents import CanIdent
-from .idents import Ident
-from .idents import IdentBuilder
-
-
-##
-
-
-class Name(Node, lang.Final):
-    ps: ta.Sequence[Ident] = dc.xfield(coerce=tuple)
-
-
-CanName: ta.TypeAlias = Name | CanIdent | ta.Sequence[CanIdent]
-
-
-class NameBuilder(IdentBuilder):
-    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)
-
-    @ta.final
-    def n(self, o: CanName) -> Name:
-        return self.name(o)