omlish 0.0.0.dev285__tar.gz → 0.0.0.dev286__tar.gz

{omlish-0.0.0.dev285/omlish.egg-info → omlish-0.0.0.dev286}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev285
+Version: 0.0.0.dev286
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -42,6 +42,7 @@ Requires-Dist: asyncpg~=0.30; extra == "all"
 Requires-Dist: apsw~=3.49; extra == "all"
 Requires-Dist: sqlean.py~=3.47; extra == "all"
 Requires-Dist: duckdb~=1.2; extra == "all"
+Requires-Dist: jinja2~=3.1; extra == "all"
 Requires-Dist: pytest~=8.3; extra == "all"
 Requires-Dist: anyio~=4.9; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
@@ -88,6 +89,8 @@ Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
 Requires-Dist: apsw~=3.49; extra == "sqldrivers"
 Requires-Dist: sqlean.py~=3.47; extra == "sqldrivers"
 Requires-Dist: duckdb~=1.2; extra == "sqldrivers"
+Provides-Extra: templates
+Requires-Dist: jinja2~=3.1; extra == "templates"
 Provides-Extra: testing
 Requires-Dist: pytest~=8.3; extra == "testing"
 Provides-Extra: plus

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev285'
-__revision__ = 'e95058137e322e352c2579564d041f21cdf1220c'
+__version__ = '0.0.0.dev286'
+__revision__ = '07fa507e06f16ab8f3ccba3d580382b07079b73e'
 
 
 #
@@ -106,6 +106,10 @@ class Project(ProjectBase):
             'duckdb ~= 1.2',
         ],
 
+        'templates': [
+            'jinja2 ~= 3.1',
+        ],
+
         'testing': [
             'pytest ~= 8.3',
         ],

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/omlish/dataclasses/generation/processor.py

@@ -36,6 +36,10 @@ class PlanOnly(ta.NamedTuple):
     b: bool
 
 
+class Verbose(ta.NamedTuple):
+    b: bool
+
+
 @register_processor_type(priority=ProcessorPriority.GENERATION)
 class GeneratorProcessor(Processor):
     class Mode(abc.ABC):
@@ -67,10 +71,11 @@ class GeneratorProcessor(Processor):
                 gp.ops(),
             )
 
-            # print(gp.prepare().plans.render())
-            # print()
-            # print(comp.src)
-            # print()
+            if (vo := gp._ctx.option(Verbose)) is not None and vo.b:  # noqa
+                print(gp.prepare().plans.render(), file=sys.stderr)
+                print(file=sys.stderr)
+                print(comp.src, file=sys.stderr)
+                print(file=sys.stderr)
 
             ns: dict = {}
             ns.update(compiler.style.globals_ns())  # noqa

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/omlish/dataclasses/processing/driving.py

@@ -1,8 +1,7 @@
 import typing as ta
 
 from .. import concerns as _concerns  # noqa  # imported for registration
-from ..generation import processor as _generation_processor  # noqa  # imported for registration
-from ..generation.processor import PlanOnly
+from ..generation import processor as gp
 from ..specs import ClassSpec
 from .base import ProcessingContext
 from .base import Processor
@@ -18,10 +17,15 @@ def drive_cls_processing(
         cs: ClassSpec,
         *,
         plan_only: bool = False,
+        verbose: bool = False,
 ) -> type:
     options: list[ta.Any] = []
     if plan_only:
-        options.append(PlanOnly(True))
+        options.append(gp.PlanOnly(True))
+    if verbose:
+        options.append(gp.Verbose(True))
+
+    #
 
     ctx = ProcessingContext(
         cls,

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/omlish/lang/maybes.py

@@ -1,6 +1,9 @@
 import abc
 import typing as ta
 
+from ..lite.maybes import Maybe as _LiteMaybe
+from ..lite.maybes import as_maybe as _as_lite_maybe
+
 
 T = ta.TypeVar('T')
 U = ta.TypeVar('U')
@@ -123,6 +126,9 @@ class _Maybe(Maybe[T], tuple):
         raise exception_supplier()
 
 
+#
+
+
 def just(v: T) -> Maybe[T]:
     return tuple.__new__(_Maybe, (v,))  # noqa
 
@@ -138,3 +144,14 @@ def maybe(o: T | None) -> Maybe[T]:
     if o is None:
         return _empty  # noqa
     return just(o)
+
+
+##
+
+
+@_as_lite_maybe.register
+def _(obj: Maybe) -> _LiteMaybe:
+    if obj.present:
+        return _LiteMaybe.just(obj.must())
+    else:
+        return _LiteMaybe.empty()

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/omlish/lite/maybes.py

@@ -1,10 +1,14 @@
 import abc
+import functools
 import typing as ta
 
 
 T = ta.TypeVar('T')
 
 
+##
+
+
 class Maybe(ta.Generic[T]):
     @property
     @abc.abstractmethod
@@ -43,3 +47,16 @@ class _Maybe(Maybe[T], tuple):
 
 
 Maybe._empty = tuple.__new__(_Maybe, ())  # noqa
+
+
+##
+
+
+@functools.singledispatch
+def as_maybe(obj: ta.Any) -> Maybe:
+    raise TypeError(obj)
+
+
+@as_maybe.register
+def _(obj: Maybe) -> Maybe:
+    return obj

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/omlish/text/minja.py

@@ -5,12 +5,14 @@ TODO:
  - raw
  - blocks / inheritance
 """
+import dataclasses as dc
 import io
 import re
 import typing as ta
 
 from ..lite.cached import cached_nullary
 from ..lite.check import check
+from ..lite.maybes import Maybe
 
 
 ##
@@ -29,6 +31,34 @@ class MinjaTemplate:
 ##
 
 
+@dc.dataclass(frozen=True)
+class MinjaTemplateParam:
+    name: str
+    default: Maybe[ta.Any] = Maybe.empty()
+
+    def __post_init__(self) -> None:
+        check.arg(self.name.isidentifier())
+
+    @classmethod
+    def of(cls, obj: ta.Union[str, 'MinjaTemplateParam']) -> 'MinjaTemplateParam':
+        if isinstance(obj, MinjaTemplateParam):
+            return obj
+        elif isinstance(obj, str):
+            return MinjaTemplateParam.new(obj)
+        else:
+            raise TypeError(obj)
+
+    @classmethod
+    def new(cls, name: str, *defaults: ta.Any) -> 'MinjaTemplateParam':
+        dfl: Maybe[ta.Any]
+        if defaults:
+            [dv] = defaults
+            dfl = Maybe.just(dv)
+        else:
+            dfl = Maybe.empty()
+        return cls(name, dfl)
+
+
 class MinjaTemplateCompiler:
     """
     Compiles a template string into a Python function. The returned function takes a dictionary 'context' and returns
@@ -43,23 +73,28 @@ class MinjaTemplateCompiler:
     - {# comment #}: Ignored completely.
     """
 
-    DEFAULT_INDENT: str = '  '
+    DEFAULT_INDENT: str = ' ' * 4
 
     def __init__(
             self,
             src: str,
-            args: ta.Sequence[str],
+            params: ta.Sequence[ta.Union[str, MinjaTemplateParam]],
             *,
             indent: str = DEFAULT_INDENT,
     ) -> None:
         super().__init__()
 
+        check.not_isinstance(params, str)
+
         self._src = check.isinstance(src, str)
-        self._args = check.not_isinstance(args, str)
+        self._params = [
+            MinjaTemplateParam.of(p)
+            for p in params
+        ]
+        check.unique(p.name for p in self._params)
         self._indent_str: str = check.non_empty_str(indent)
 
         self._stack: ta.List[ta.Literal['for', 'if']] = []
-        self._lines: ta.List[str] = []
 
     #
 
@@ -124,41 +159,63 @@ class MinjaTemplateCompiler:
 
     _RENDER_FN_NAME = '__render'
 
+    class Rendered(ta.NamedTuple):
+        src: str
+        ns: ta.Dict[str, ta.Any]
+
     @cached_nullary
-    def render(self) -> ta.Tuple[str, ta.Mapping[str, ta.Any]]:
+    def render(self) -> Rendered:
+        lines: ta.List[str] = []
+
+        ns: ta.Dict[str, ta.Any] = {
+            '__StringIO': io.StringIO,
+        }
+
         parts = self._split_tags(self._src)
 
-        self._lines.append(f'def {self._RENDER_FN_NAME}({", ".join(self._args)}):')
-        self._lines.append(self._indent('__output = __StringIO()'))
+        if not self._params:
+            lines.append(f'def {self._RENDER_FN_NAME}():')
+        else:
+            lines.append(f'def {self._RENDER_FN_NAME}(')
+            for p in self._params:
+                if p.default.present:
+                    check.not_in(p.name, ns)
+                    ns[p.name] = p.default.must()
+                    lines.append(self._indent(f'{p.name}={p.name},'))
+                else:
+                    lines.append(self._indent(f'{p.name},'))
+            lines.append('):')
+
+        lines.append(self._indent('__output = __StringIO()'))
 
         for g, s in parts:
             if g == '{':
                 expr = s.strip()
-                self._lines.append(self._indent(f'__output.write(str({expr}))'))
+                lines.append(self._indent(f'__output.write(str({expr}))'))
 
             elif g == '%':
                 stmt = s.strip()
 
                 if stmt.startswith('for '):
-                    self._lines.append(self._indent(stmt + ':'))
+                    lines.append(self._indent(stmt + ':'))
                     self._stack.append('for')
                 elif stmt.startswith('endfor'):
                     check.equal(self._stack.pop(), 'for')
 
                 elif stmt.startswith('if '):
-                    self._lines.append(self._indent(stmt + ':'))
+                    lines.append(self._indent(stmt + ':'))
                     self._stack.append('if')
                 elif stmt.startswith('elif '):
                     check.equal(self._stack[-1], 'if')
-                    self._lines.append(self._indent(stmt + ':', -1))
+                    lines.append(self._indent(stmt + ':', -1))
                 elif stmt.strip() == 'else':
                     check.equal(self._stack[-1], 'if')
-                    self._lines.append(self._indent('else:', -1))
+                    lines.append(self._indent('else:', -1))
                 elif stmt.startswith('endif'):
                     check.equal(self._stack.pop(), 'if')
 
                 else:
-                    self._lines.append(self._indent(stmt))
+                    lines.append(self._indent(stmt))
 
             elif g == '#':
                 pass
@@ -166,20 +223,16 @@ class MinjaTemplateCompiler:
             elif not g:
                 if s:
                     safe_text = s.replace('"""', '\\"""')
-                    self._lines.append(self._indent(f'__output.write("""{safe_text}""")'))
+                    lines.append(self._indent(f'__output.write("""{safe_text}""")'))
 
             else:
                 raise KeyError(g)
 
         check.empty(self._stack)
 
-        self._lines.append(self._indent('return __output.getvalue()'))
-
-        ns = {
-            '__StringIO': io.StringIO,
-        }
+        lines.append(self._indent('return __output.getvalue()'))
 
-        return ('\n'.join(self._lines), ns)
+        return self.Rendered('\n'.join(lines), ns)
 
     #
 
@@ -200,12 +253,12 @@ class MinjaTemplateCompiler:
 
     @cached_nullary
     def compile(self) -> MinjaTemplate:
-        render_src, render_ns = self.render()
+        rendered = self.render()
 
         render_fn = self._make_fn(
             self._RENDER_FN_NAME,
-            render_src,
-            render_ns,
+            rendered.src,
+            rendered.ns,
         )
 
         return MinjaTemplate(render_fn)
@@ -214,8 +267,11 @@ class MinjaTemplateCompiler:
 ##
 
 
-def compile_minja_template(src: str, args: ta.Sequence[str] = ()) -> MinjaTemplate:
-    return MinjaTemplateCompiler(src, args).compile()
+def compile_minja_template(
+        src: str,
+        params: ta.Sequence[ta.Union[str, MinjaTemplateParam]] = (),
+) -> MinjaTemplate:
+    return MinjaTemplateCompiler(src, params).compile()
 
 
 def render_minja_template(src: str, **kwargs: ta.Any) -> str:

omlish-0.0.0.dev286/omlish/text/templating.py

@@ -0,0 +1,116 @@
+import abc
+import dataclasses as dc
+import string
+import typing as ta
+
+from .. import lang
+from .minja import MinjaTemplate
+from .minja import MinjaTemplateParam
+from .minja import compile_minja_template
+
+
+if ta.TYPE_CHECKING:
+    import jinja2
+else:
+    jinja2 = lang.proxy_import('jinja2')
+
+
+##
+
+
+class Templater(lang.Abstract):
+    @dc.dataclass(frozen=True)
+    class Context:
+        env: ta.Mapping[str, ta.Any] | None = None
+
+    @abc.abstractmethod
+    def render(self, ctx: Context) -> str:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FormatTemplater(Templater):
+    """https://docs.python.org/3/library/string.html#format-specification-mini-language"""
+
+    fmt: str
+
+    def render(self, ctx: Templater.Context) -> str:
+        return self.fmt.format(**(ctx.env or {}))
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Pep292Templater(Templater):
+    """https://peps.python.org/pep-0292/"""
+
+    tmpl: string.Template
+
+    def render(self, ctx: Templater.Context) -> str:
+        return self.tmpl.substitute(ctx.env or {})
+
+    @classmethod
+    def from_string(cls, src: str) -> 'Pep292Templater':
+        return cls(string.Template(src))
+
+##
+
+
+@dc.dataclass(frozen=True)
+class MinjaTemplater(Templater):
+    tmpl: MinjaTemplate
+
+    ENV_IDENT: ta.ClassVar[str] = 'env'
+
+    def render(self, ctx: Templater.Context) -> str:
+        return self.tmpl(**{self.ENV_IDENT: ctx.env or {}})
+
+    @classmethod
+    def from_string(
+            cls,
+            src: str,
+            **ns: ta.Any,
+    ) -> 'MinjaTemplater':
+        tmpl = compile_minja_template(
+            src,
+            [
+                MinjaTemplateParam(cls.ENV_IDENT),
+                *[
+                    MinjaTemplateParam.new(k, v)
+                    for k, v in ns.items()
+                ],
+            ],
+        )
+
+        return cls(tmpl)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class JinjaTemplater(Templater):
+    tmpl: jinja2.Template
+
+    def render(self, ctx: Templater.Context) -> str:
+        return self.tmpl.render(**(ctx.env or {}))
+
+    @classmethod
+    def from_string(
+            cls,
+            src: str,
+            *,
+            env: jinja2.Environment | None = None,
+            **kwargs: ta.Any,
+    ) -> 'JinjaTemplater':
+        if env is None:
+            env = jinja2.Environment()
+        tmpl = env.from_string(src)
+        return cls(
+            tmpl,
+            **kwargs,
+        )

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev285
+Version: 0.0.0.dev286
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -42,6 +42,7 @@ Requires-Dist: asyncpg~=0.30; extra == "all"
 Requires-Dist: apsw~=3.49; extra == "all"
 Requires-Dist: sqlean.py~=3.47; extra == "all"
 Requires-Dist: duckdb~=1.2; extra == "all"
+Requires-Dist: jinja2~=3.1; extra == "all"
 Requires-Dist: pytest~=8.3; extra == "all"
 Requires-Dist: anyio~=4.9; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
@@ -88,6 +89,8 @@ Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
 Requires-Dist: apsw~=3.49; extra == "sqldrivers"
 Requires-Dist: sqlean.py~=3.47; extra == "sqldrivers"
 Requires-Dist: duckdb~=1.2; extra == "sqldrivers"
+Provides-Extra: templates
+Requires-Dist: jinja2~=3.1; extra == "templates"
 Provides-Extra: testing
 Requires-Dist: pytest~=8.3; extra == "testing"
 Provides-Extra: plus

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/omlish.egg-info/SOURCES.txt

@@ -829,6 +829,7 @@ omlish/text/mangle.py
 omlish/text/minja.py
 omlish/text/parts.py
 omlish/text/random.py
+omlish/text/templating.py
 omlish/text/go/__init__.py
 omlish/text/go/quoting.py
 omlish/typedvalues/__init__.py

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/omlish.egg-info/requires.txt

@@ -29,6 +29,7 @@ asyncpg~=0.30
 apsw~=3.49
 sqlean.py~=3.47
 duckdb~=1.2
+jinja2~=3.1
 pytest~=8.3
 
 [async]
@@ -87,5 +88,8 @@ apsw~=3.49
 sqlean.py~=3.47
 duckdb~=1.2
 
+[templates]
+jinja2~=3.1
+
 [testing]
 pytest~=8.3

{omlish-0.0.0.dev285 → omlish-0.0.0.dev286}/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.dev285'
+version = '0.0.0.dev286'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',
@@ -53,6 +53,7 @@ all = [
     'apsw ~= 3.49',
     'sqlean.py ~= 3.47',
     'duckdb ~= 1.2',
+    'jinja2 ~= 3.1',
     'pytest ~= 8.3',
     'anyio ~= 4.9',
     'sniffio ~= 1.3',
@@ -109,6 +110,9 @@ sqldrivers = [
     'sqlean.py ~= 3.47',
     'duckdb ~= 1.2',
 ]
+templates = [
+    'jinja2 ~= 3.1',
+]
 testing = [
     'pytest ~= 8.3',
 ]