omlish 0.0.0.dev178__tar.gz → 0.0.0.dev179__tar.gz

{omlish-0.0.0.dev178/omlish.egg-info → omlish-0.0.0.dev179}/PKG-INFO

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

{omlish-0.0.0.dev178 → omlish-0.0.0.dev179}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev178'
-__revision__ = 'fd8b9c2c51797566d0d9a52a8b347895029c82f5'
+__version__ = '0.0.0.dev179'
+__revision__ = '40949c92a73910f364c60391f73bb2fcf9538caf'
 
 
 #

{omlish-0.0.0.dev178 → omlish-0.0.0.dev179}/omlish/dataclasses/impl/hashing.py

@@ -50,7 +50,8 @@ class HashProcessor(Processor):
         if self._info.params_extras.cache_hash:
             body = [
                 f'try: return self.{self.CACHED_HASH_ATTR}',
-                f'except AttributeError: object.__setattr__(self, {self.CACHED_HASH_ATTR!r}, h := hash({self_tuple}))',
+                f'except AttributeError: pass',
+                f'object.__setattr__(self, {self.CACHED_HASH_ATTR!r}, h := hash({self_tuple}))',
                 f'return h',
             ]
         else:

{omlish-0.0.0.dev178 → omlish-0.0.0.dev179}/omlish/inject/elements.py

@@ -1,7 +1,6 @@
 import abc
 import typing as ta
 
-from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .impl.origins import HasOriginsImpl
@@ -19,8 +18,8 @@ class ElementGenerator(lang.Abstract, lang.PackageSealed):
 
 @dc.dataclass(frozen=True)
 class Elements(lang.Final):
-    es: frozenset[Element] | None = dc.xfield(None, coerce=check.of_isinstance((frozenset, None)))
-    cs: frozenset['Elements'] | None = dc.xfield(None, coerce=check.of_isinstance((frozenset, None)))
+    es: ta.Collection[Element] | None = None
+    cs: ta.Collection['Elements'] | None = None
 
     def __iter__(self) -> ta.Generator[Element, None, None]:
         if self.es:
@@ -38,14 +37,14 @@ Elemental = ta.Union[  # noqa
 
 
 def as_elements(*args: Elemental) -> Elements:
-    es: set[Element] = set()
-    cs: set[Elements] = set()
+    es: list[Element] = []
+    cs: list[Elements] = []
 
     def rec(a):
         if isinstance(a, Element):
-            es.add(a)
+            es.append(a)
         elif isinstance(a, Elements):
-            cs.add(a)
+            cs.append(a)
         elif isinstance(a, ElementGenerator):
             for n in a:
                 rec(n)
@@ -59,6 +58,6 @@ def as_elements(*args: Elemental) -> Elements:
         return next(iter(cs))
 
     return Elements(
-        frozenset(es) if es else None,
-        frozenset(cs) if cs else None,
+        es if es else None,
+        cs if cs else None,
     )

{omlish-0.0.0.dev178 → omlish-0.0.0.dev179}/omlish/lite/inject.py

@@ -291,30 +291,6 @@ def as_injector_bindings(*args: InjectorBindingOrBindings) -> InjectorBindings:
 ##
 
 
-@dc.dataclass(frozen=True)
-class OverridesInjectorBindings(InjectorBindings):
-    p: InjectorBindings
-    m: ta.Mapping[InjectorKey, InjectorBinding]
-
-    def bindings(self) -> ta.Iterator[InjectorBinding]:
-        for b in self.p.bindings():
-            yield self.m.get(b.key, b)
-
-
-def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
-    m: ta.Dict[InjectorKey, InjectorBinding] = {}
-
-    for b in as_injector_bindings(*args).bindings():
-        if b.key in m:
-            raise DuplicateInjectorKeyError(b.key)
-        m[b.key] = b
-
-    return OverridesInjectorBindings(p, m)
-
-
-##
-
-
 def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey, InjectorProvider]:
     pm: ta.Dict[InjectorKey, InjectorProvider] = {}
     am: ta.Dict[InjectorKey, ta.List[InjectorProvider]] = {}
@@ -338,6 +314,31 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
     return pm
 
 
+###
+# overrides
+
+
+@dc.dataclass(frozen=True)
+class OverridesInjectorBindings(InjectorBindings):
+    p: InjectorBindings
+    m: ta.Mapping[InjectorKey, InjectorBinding]
+
+    def bindings(self) -> ta.Iterator[InjectorBinding]:
+        for b in self.p.bindings():
+            yield self.m.get(b.key, b)
+
+
+def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
+    m: ta.Dict[InjectorKey, InjectorBinding] = {}
+
+    for b in as_injector_bindings(*args).bindings():
+        if b.key in m:
+            raise DuplicateInjectorKeyError(b.key)
+        m[b.key] = b
+
+    return OverridesInjectorBindings(p, m)
+
+
 ###
 # scopes
 
@@ -362,7 +363,7 @@ class InjectorScope(abc.ABC):  # noqa
     @dc.dataclass(frozen=True)
     class State:
         seeds: ta.Dict[InjectorKey, ta.Any]
-        prvs: ta.Dict[InjectorKey, ta.Any] = dc.field(default_factory=dict)
+        provisions: ta.Dict[InjectorKey, ta.Any] = dc.field(default_factory=dict)
 
     def new_state(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> State:
         vs = dict(vs)
@@ -442,11 +443,11 @@ class ScopedInjectorProvider(InjectorProvider):
         def pfn(i: Injector) -> ta.Any:
             st = i[self.sc].state()
             try:
-                return st.prvs[self.k]
+                return st.provisions[self.k]
             except KeyError:
                 pass
             v = ufn(i)
-            st.prvs[self.k] = v
+            st.provisions[self.k] = v
             return v
 
         ufn = self.p.provider_fn()
@@ -470,9 +471,7 @@ class _ScopeSeedInjectorProvider(InjectorProvider):
 
 
 def bind_injector_scope(sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
-    return as_injector_bindings(
-        InjectorBinder.bind(sc, singleton=True),
-    )
+    return InjectorBinder.bind(sc, singleton=True)
 
 
 #
@@ -1012,6 +1011,8 @@ class InjectionApi:
     def as_bindings(self, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return as_injector_bindings(*args)
 
+    # overrides
+
     def override(self, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 

omlish-0.0.0.dev179/omlish/text/minja.py

@@ -0,0 +1,223 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+TODO:
+ - raw
+ - blocks / inheritance
+"""
+import io
+import re
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+from omlish.lite.check import check
+
+
+##
+
+
+class MinjaTemplate:
+    def __init__(self, fn: ta.Callable) -> None:
+        super().__init__()
+
+        self._fn = fn
+
+    def __call__(self, **kwargs: ta.Any) -> str:
+        return self._fn(**kwargs)
+
+
+##
+
+
+class MinjaTemplateCompiler:
+    """
+    Compiles a template string into a Python function. The returned function takes a dictionary 'context' and returns
+    the rendered string.
+
+    Supported syntax:
+    - Literal text remains literal.
+    - {{ expr }}: Evaluates 'expr' in the given context and writes its str() to output.
+    - {% code %}: Executes the given Python code (e.g. 'for x in items:'), must be terminated appropriately.
+    - {% endfor %} to close for loops.
+    - {% endif %} to close if blocks.
+    - {# comment #}: Ignored completely.
+    """
+
+    DEFAULT_INDENT: str = '  '
+
+    def __init__(
+            self,
+            src: str,
+            args: ta.Sequence[str],
+            *,
+            indent: str = DEFAULT_INDENT,
+    ) -> None:
+        super().__init__()
+
+        self._src = check.isinstance(src, str)
+        self._args = check.not_isinstance(args, str)
+        self._indent_str: str = check.non_empty_str(indent)
+
+        self._stack: ta.List[ta.Literal['for', 'if']] = []
+        self._lines: ta.List[str] = []
+
+    #
+
+    _TAG_PAT = re.compile(
+        r'({{.*?}}|{%.*?%}|{#.*?#})',
+        flags=re.DOTALL,
+    )
+
+    @classmethod
+    def _split_tags(cls, src: str) -> ta.List[ta.Tuple[str, str]]:
+        raw = cls._TAG_PAT.split(src)
+
+        #
+
+        parts: ta.List[ta.Tuple[str, str]] = []
+        for s in raw:
+            if not s:
+                continue
+
+            for g, l, r in [
+                ('{', '{{', '}}'),
+                ('%', '{%', '%}'),
+                ('#', '{#', '#}'),
+            ]:
+                if s.startswith(l) and s.endswith(r):
+                    parts.append((g, s[len(l):-len(r)]))
+                    break
+            else:
+                parts.append(('', s))
+
+        #
+
+        for i, (g, s) in enumerate(parts):
+            if s.startswith('-'):
+                if i > 0:
+                    lg, ls = parts[i - 1]
+                    parts[i - 1] = (lg, ls.rstrip())
+                s = s[1:].lstrip()
+
+            if s.endswith('-'):
+                if i < len(parts) - 1:
+                    rg, rs = parts[i + 1]
+                    parts[i + 1] = (rg, rs.lstrip())
+                s = s[:-1].rstrip()
+
+            parts[i] = (g, s)
+
+        #
+
+        parts = [(g, s) for g, s in parts if g or s]
+
+        #
+
+        return parts
+
+    #
+
+    def _indent(self, line: str, ofs: int = 0) -> str:
+        return self._indent_str * (len(self._stack) + 1 + ofs) + line
+
+    #
+
+    _RENDER_FN_NAME = '__render'
+
+    @cached_nullary
+    def render(self) -> ta.Tuple[str, ta.Mapping[str, ta.Any]]:
+        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()'))
+
+        for g, s in parts:
+            if g == '{':
+                expr = s.strip()
+                self._lines.append(self._indent(f'__output.write(str({expr}))'))
+
+            elif g == '%':
+                stmt = s.strip()
+
+                if stmt.startswith('for '):
+                    self._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 + ':'))
+                    self._stack.append('if')
+                elif stmt.startswith('elif '):
+                    check.equal(self._stack[-1], 'if')
+                    self._lines.append(self._indent(stmt + ':', -1))
+                elif stmt.strip() == 'else':
+                    check.equal(self._stack[-1], 'if')
+                    self._lines.append(self._indent('else:', -1))
+                elif stmt.startswith('endif'):
+                    check.equal(self._stack.pop(), 'if')
+
+                else:
+                    self._lines.append(self._indent(stmt))
+
+            elif g == '#':
+                pass
+
+            elif not g:
+                if s:
+                    safe_text = s.replace('"""', '\\"""')
+                    self._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,
+        }
+
+        return ('\n'.join(self._lines), ns)
+
+    #
+
+    @classmethod
+    def _make_fn(
+            cls,
+            name: str,
+            src: str,
+            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Callable:
+        glo: dict = {}
+        if ns:
+            glo.update(ns)
+        exec(src, glo)
+        return glo[name]
+
+    #
+
+    @cached_nullary
+    def compile(self) -> MinjaTemplate:
+        render_src, render_ns = self.render()
+
+        render_fn = self._make_fn(
+            self._RENDER_FN_NAME,
+            render_src,
+            render_ns,
+        )
+
+        return MinjaTemplate(render_fn)
+
+
+##
+
+
+def compile_minja_template(src: str, args: ta.Sequence[str] = ()) -> MinjaTemplate:
+    return MinjaTemplateCompiler(src, args).compile()
+
+
+def render_minja_template(src: str, **kwargs: ta.Any) -> str:
+    tmpl = compile_minja_template(src, list(kwargs))
+    return tmpl(**kwargs)

{omlish-0.0.0.dev178 → omlish-0.0.0.dev179/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev178 → omlish-0.0.0.dev179}/omlish.egg-info/SOURCES.txt

@@ -578,5 +578,6 @@ omlish/text/asdl.py
 omlish/text/delimit.py
 omlish/text/glyphsplit.py
 omlish/text/indent.py
+omlish/text/minja.py
 omlish/text/parts.py
 omlish/text/random.py

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