omlish 0.0.0.dev199__tar.gz → 0.0.0.dev201__tar.gz

{omlish-0.0.0.dev199/omlish.egg-info → omlish-0.0.0.dev201}/PKG-INFO

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

{omlish-0.0.0.dev199 → omlish-0.0.0.dev201}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev199'
-__revision__ = '19849595c30a781a42e5587cf2915dd1fcc1211a'
+__version__ = '0.0.0.dev201'
+__revision__ = '77be9dbd97d16b54293dbf9f3803e3fa882ecc5f'
 
 
 #

omlish-0.0.0.dev201/omlish/configs/all.py

@@ -0,0 +1,43 @@
+# ruff: noqa: I001
+from .formats import (  # noqa
+    ConfigData as Data,
+
+    ConfigLoader as Loader,
+
+    ConfigRenderer as Renderer,
+
+    ObjConfigData as ObjData,
+
+    JsonConfigData as JsonData,
+    JsonConfigLoader as JsonLoader,
+    JsonConfigRenderer as JsonRenderer,
+
+    TomlConfigData as TomlData,
+    TomlConfigLoader as TomlLoader,
+    TomlConfigRenderer as TomlRenderer,
+
+    YamlConfigData as YamlData,
+    YamlConfigLoader as YamlLoader,
+    YamlConfigRenderer as YamlRenderer,
+
+    IniConfigData as IniData,
+    IniConfigLoader as IniLoader,
+    IniConfigRenderer as IniRenderer,
+
+    SwitchedConfigFileLoader as SwitchedFileLoader,
+
+    DEFAULT_CONFIG_LOADERS as DEFAULT_LOADERS,
+    DEFAULT_CONFIG_LOADER as DEFAULT_LOADER,
+    DEFAULT_CONFIG_FILE_LOADER as DEFAULT_FILE_LOADER,
+
+    SwitchedConfigRenderer as SwitchedRenderer,
+
+    DEFAULT_CONFIG_RENDERERS as DEFAULT_RENDERERS,
+    DEFAULT_CONFIG_RENDERER as DEFAULT_RENDERER,
+)
+
+from .types import (  # noqa
+    ConfigMap as Map,
+)
+
+from .processing import all as processing  # noqa

omlish-0.0.0.dev201/omlish/configs/processing/all.py

@@ -0,0 +1,33 @@
+# ruff: noqa: I001
+from .flattening import (  # noqa
+    ConfigFlattening as Flattening,
+)
+
+from .inheritance import (  # noqa
+    build_config_inherited_values as build_inherited_values,
+)
+
+from .matching import (  # noqa
+    MatchingConfigRewriter as MatchingRewriter,
+
+    matched_config_rewrite as matched_rewrite,
+)
+
+from .names import (  # noqa
+    build_config_named_children as build_named_children,
+)
+
+from .rewriting import (  # noqa
+    ConfigRewriterItem as RewriterItem,
+    ConfigRewriterPath as RewriterPath,
+
+    RawConfigMetadata as RawMetadata,
+
+    ConfigRewriter as Rewriter,
+)
+
+from .strings import (  # noqa
+    StringConfigRewriter as StringRewriter,
+
+    format_config_strings as format_strings,
+)

{omlish-0.0.0.dev199 → omlish-0.0.0.dev201}/omlish/sql/queries/inserts.py

@@ -30,7 +30,7 @@ class Insert(Stmt, lang.Final):
 CanValues: ta.TypeAlias = Values | ta.Sequence[CanExpr]
 
 
-class InsertBuilder(ExprBuilder, RelationBuilder):
+class InsertBuilder(RelationBuilder, ExprBuilder):
     def values(self, vs: CanValues) -> Values:
         if isinstance(vs, Values):
             return vs

{omlish-0.0.0.dev199 → omlish-0.0.0.dev201}/omlish/sql/queries/marshal.py

@@ -17,6 +17,7 @@ from .binary import BinaryOps
 from .exprs import Expr
 from .inserts import Values
 from .multi import MultiKind
+from .relations import JoinKind
 from .relations import Relation
 from .selects import Select
 from .stmts import Stmt
@@ -66,8 +67,12 @@ def _install_standard_marshalling() -> None:
         msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.TypeMapMarshalerFactory({ty: OpMarshalerUnmarshaler(ty, ns)})]
         msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.TypeMapUnmarshalerFactory({ty: OpMarshalerUnmarshaler(ty, ns)})]
 
-    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.TypeMapMarshalerFactory({MultiKind: LowerEnumMarshaler(MultiKind)})]
-    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.TypeMapUnmarshalerFactory({MultiKind: LowerEnumMarshaler(MultiKind)})]  # noqa
+    ets = [
+        JoinKind,
+        MultiKind,
+    ]
+    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.TypeMapMarshalerFactory({t: LowerEnumMarshaler(t) for t in ets})]
+    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.TypeMapUnmarshalerFactory({t: LowerEnumMarshaler(t) for t in ets})]
 
     for cls in [
         Expr,

omlish-0.0.0.dev201/omlish/sql/queries/relations.py

@@ -0,0 +1,125 @@
+"""
+TODO:
+ - join
+ - subquery
+"""
+import enum
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from .base import Node
+from .exprs import CanExpr
+from .exprs import Expr
+from .idents import Ident
+from .multi import MultiBuilder
+from .names import CanName
+from .names import Name
+
+
+##
+
+
+class Relation(Node, lang.Abstract):
+    pass
+
+
+#
+
+
+class Table(Relation, lang.Final):
+    n: Name
+    a: Ident | None = dc.xfield(None, repr_fn=dc.opt_repr)
+
+
+#
+
+
+class JoinKind(enum.Enum):
+    DEFAULT = enum.auto()
+    INNER = enum.auto()
+    LEFT = enum.auto()
+    LEFT_OUTER = enum.auto()
+    RIGHT = enum.auto()
+    RIGHT_OUTER = enum.auto()
+    FULL = enum.auto()
+    FULL_OUTER = enum.auto()
+    CROSS = enum.auto()
+    NATURAL = enum.auto()
+
+
+class Join(Relation, lang.Final):
+    k: JoinKind
+    l: Relation
+    r: Relation
+
+    c: Expr | None = None
+
+
+##
+
+
+CanTable: ta.TypeAlias = Table | CanName
+CanRelation: ta.TypeAlias = Relation | CanTable
+
+
+class RelationBuilder(MultiBuilder):
+    def table(self, n: CanTable) -> Table:
+        if isinstance(n, Table):
+            return n
+        else:
+            return Table(self.name(n))
+
+    #
+
+    def join(
+            self,
+            k: JoinKind,
+            l: CanRelation,
+            r: CanRelation,
+            *cs: CanExpr,
+    ) -> Join:
+        return Join(
+            k,
+            self.relation(l),
+            self.relation(r),
+            self.or_(*cs) if cs else None,
+        )
+
+    def default_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.DEFAULT, l, r, *cs)
+
+    def inner_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.INNER, l, r, *cs)
+
+    def left_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.LEFT, l, r, *cs)
+
+    def left_outer_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.LEFT_OUTER, l, r, *cs)
+
+    def right_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.RIGHT, l, r, *cs)
+
+    def right_outer_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.RIGHT_OUTER, l, r, *cs)
+
+    def full_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.FULL, l, r, *cs)
+
+    def full_outer_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.FULL_OUTER, l, r, *cs)
+
+    def cross_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.CROSS, l, r, *cs)
+
+    def natural_join(self, l: CanRelation, r: CanRelation, *cs: CanExpr) -> Join:
+        return self.join(JoinKind.NATURAL, l, r, *cs)
+
+    #
+
+    def relation(self, o: CanRelation) -> Relation:
+        if isinstance(o, Relation):
+            return o
+        else:
+            return self.table(o)

{omlish-0.0.0.dev199 → omlish-0.0.0.dev201}/omlish/sql/queries/rendering.py

@@ -36,6 +36,8 @@ from .multi import Multi
 from .multi import MultiKind
 from .names import Name
 from .params import Param
+from .relations import Join
+from .relations import JoinKind
 from .relations import Table
 from .selects import Select
 from .selects import SelectItem
@@ -156,7 +158,6 @@ class StdRenderer(Renderer):
     MULTI_KIND_TO_STR: ta.ClassVar[ta.Mapping[MultiKind, str]] = {
         MultiKind.AND: 'and',
         MultiKind.OR: 'or',
-
     }
 
     @Renderer.render.register
@@ -187,6 +188,30 @@ class StdRenderer(Renderer):
             self._out.write(' as ')
             self.render(o.a)
 
+    JOIN_KIND_TO_STR: ta.ClassVar[ta.Mapping[JoinKind, str]] = {
+        JoinKind.DEFAULT: 'join',
+        JoinKind.INNER: 'inner join',
+        JoinKind.LEFT: 'left join',
+        JoinKind.LEFT_OUTER: 'left outer join',
+        JoinKind.RIGHT: 'right join',
+        JoinKind.RIGHT_OUTER: 'right outer join',
+        JoinKind.FULL: 'full join',
+        JoinKind.FULL_OUTER: 'full outer join',
+        JoinKind.CROSS: 'cross join',
+        JoinKind.NATURAL: 'natural join',
+    }
+
+    @Renderer.render.register
+    def render_join(self, o: Join) -> None:
+        self.render(o.l)
+        self._out.write(' ')
+        self._out.write(self.JOIN_KIND_TO_STR[o.k])
+        self._out.write(' ')
+        self.render(o.r)
+        if o.c is not None:
+            self._out.write(' on ')
+            self.render(o.c)
+
     # selects
 
     @Renderer.render.register

{omlish-0.0.0.dev199 → omlish-0.0.0.dev201}/omlish/sql/queries/selects.py

@@ -30,7 +30,7 @@ class Select(Stmt, lang.Final):
 CanSelectItem: ta.TypeAlias = SelectItem | CanExpr
 
 
-class SelectBuilder(ExprBuilder, RelationBuilder):
+class SelectBuilder(RelationBuilder, ExprBuilder):
     def select_item(self, o: CanSelectItem) -> SelectItem:
         if isinstance(o, SelectItem):
             return o

{omlish-0.0.0.dev199 → omlish-0.0.0.dev201/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev199 → omlish-0.0.0.dev201}/omlish.egg-info/SOURCES.txt

@@ -160,11 +160,13 @@ omlish/concurrent/executors.py
 omlish/concurrent/futures.py
 omlish/concurrent/threadlets.py
 omlish/configs/__init__.py
+omlish/configs/all.py
 omlish/configs/classes.py
 omlish/configs/formats.py
 omlish/configs/nginx.py
 omlish/configs/types.py
 omlish/configs/processing/__init__.py
+omlish/configs/processing/all.py
 omlish/configs/processing/flattening.py
 omlish/configs/processing/inheritance.py
 omlish/configs/processing/matching.py

{omlish-0.0.0.dev199 → omlish-0.0.0.dev201}/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.dev199'
+version = '0.0.0.dev201'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev199/omlish/sql/queries/relations.py

@@ -1,44 +0,0 @@
-"""
-TODO:
- - join
- - subquery
-"""
-import typing as ta
-
-from ... import dataclasses as dc
-from ... import lang
-from .base import Node
-from .idents import Ident
-from .names import CanName
-from .names import Name
-from .names import NameBuilder
-
-
-##
-
-
-class Relation(Node, lang.Abstract):
-    pass
-
-
-class Table(Relation, lang.Final):
-    n: Name
-    a: Ident | None = dc.xfield(None, repr_fn=dc.opt_repr)
-
-
-CanTable: ta.TypeAlias = Table | CanName
-CanRelation: ta.TypeAlias = Relation | CanTable
-
-
-class RelationBuilder(NameBuilder):
-    def table(self, n: CanTable) -> Table:
-        if isinstance(n, Table):
-            return n
-        else:
-            return Table(self.name(n))
-
-    def relation(self, o: CanRelation) -> Relation:
-        if isinstance(o, Relation):
-            return o
-        else:
-            return self.table(o)