omlish 0.0.0.dev192__py3-none-any.whl → 0.0.0.dev194__py3-none-any.whl

omlish/configs/processing/rewriting.py

@@ -0,0 +1,141 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import abc
+import collections.abc
+import dataclasses as dc
+import typing as ta
+
+from ...lite.check import check
+from ...lite.types import BUILTIN_SCALAR_ITERABLE_TYPES
+
+
+T = ta.TypeVar('T')
+StrT = ta.TypeVar('StrT', bound=str)
+MappingT = ta.TypeVar('MappingT', bound=ta.Mapping)
+IterableT = ta.TypeVar('IterableT', bound=ta.Iterable)
+
+ConfigRewriterItem = ta.Union[int, str, None]  # ta.TypeAlias
+ConfigRewriterPath = ta.Tuple[ConfigRewriterItem, ...]  # ta.TypeAlias
+
+
+##
+
+
+class RawConfigMetadata:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+
+class ConfigRewriter(abc.ABC):  # noqa
+    @dc.dataclass(frozen=True)
+    class Context(ta.Generic[T]):
+        obj: T
+
+        parent: ta.Optional['ConfigRewriter.Context'] = None
+        item: ConfigRewriterItem = None
+
+        raw: bool = False
+
+        def __post_init__(self) -> None:
+            if self.parent is None:
+                check.none(self.item)
+
+        @property
+        def path(self) -> ConfigRewriterPath:
+            cur: ConfigRewriter.Context = self
+            lst: ta.List[ConfigRewriterItem] = []
+            while True:
+                if cur.parent is None:
+                    break
+                lst.append(cur.item)
+                cur = cur.parent
+            return tuple(reversed(lst))
+
+        def make_child(
+                self,
+                obj: ta.Any,
+                item: ConfigRewriterItem,
+                **kwargs: ta.Any,
+        ) -> 'ConfigRewriter.Context':
+            return dc.replace(
+                self,
+                obj=obj,
+                parent=self,
+                item=item,
+                **kwargs,
+            )
+
+    def rewrite_none(self, ctx: Context[None]) -> ta.Any:
+        return ctx.obj
+
+    def rewrite_dataclass(self, ctx: Context[T]) -> T:
+        kw = {}
+        for f in dc.fields(ctx.obj):  # type: ignore
+            fv = getattr(ctx.obj, f.name)
+            nfv: ta.Any = self.rewrite(ctx.make_child(
+                fv,
+                f.name,
+                raw=bool(not f.metadata.get(RawConfigMetadata)),
+            ))
+            if fv is not nfv:
+                kw[f.name] = nfv
+        if not kw:
+            return ctx.obj
+        return dc.replace(ctx.obj, **kw)  # type: ignore
+
+    def rewrite_str(self, ctx: Context[StrT]) -> StrT:
+        return ctx.obj
+
+    def rewrite_builtin_scalar_iterable(self, ctx: Context[IterableT]) -> IterableT:
+        return ctx.obj
+
+    def rewrite_mapping(self, ctx: Context[MappingT]) -> MappingT:
+        nm = []
+        b = False
+        for mk, mv in ctx.obj.items():
+            nk: ta.Any = self.rewrite(ctx.make_child(mk, None))
+            nv: ta.Any = self.rewrite(ctx.make_child(mv, nk))
+            nm.append((nk, nv))
+            b |= nk is not mk or nv is not mv
+        if not b:
+            return ctx.obj
+        return type(ctx.obj)(nm)  # type: ignore
+
+    def rewrite_iterable(self, ctx: Context[IterableT]) -> IterableT:
+        nl = []
+        b = False
+        for i, le in enumerate(ctx.obj):
+            ne: ta.Any = self.rewrite(ctx.make_child(le, i))
+            nl.append(ne)
+            b |= ne is not le
+        if not b:
+            return ctx.obj
+        return type(ctx.obj)(nl)  # type: ignore
+
+    def rewrite_other(self, ctx: Context[T]) -> T:
+        return ctx.obj
+
+    def rewrite(self, ctx: Context[T]) -> T:
+        if ctx.obj is None:
+            return self.rewrite_none(ctx)  # type: ignore
+
+        elif dc.is_dataclass(ctx.obj):
+            return self.rewrite_dataclass(ctx)
+
+        elif isinstance(ctx.obj, str):
+            return self.rewrite_str(ctx)  # type: ignore
+
+        elif isinstance(ctx.obj, BUILTIN_SCALAR_ITERABLE_TYPES):
+            return self.rewrite_builtin_scalar_iterable(ctx)  # type: ignore
+
+        elif isinstance(ctx.obj, collections.abc.Mapping):
+            return self.rewrite_mapping(ctx)  # type: ignore
+
+        elif isinstance(ctx.obj, (collections.abc.Sequence, collections.abc.Set)):
+            return self.rewrite_iterable(ctx)  # type: ignore
+
+        else:
+            return self.rewrite_other(ctx)
+
+    def __call__(self, v: T) -> T:
+        return self.rewrite(self.Context(obj=v))

omlish/configs/processing/strings.py

@@ -0,0 +1,45 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+TODO:
+ - env vars
+ - coalescing - {$FOO|$BAR|baz}
+ - minja?
+"""
+import typing as ta
+
+from .rewriting import ConfigRewriter
+
+
+T = ta.TypeVar('T')
+StrT = ta.TypeVar('StrT', bound=str)
+
+
+##
+
+
+class StringConfigRewriter(ConfigRewriter):
+    def __init__(
+            self,
+            fn: ta.Optional[ta.Callable[[str], str]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._fn = fn
+
+    def rewrite_str(self, ctx: ConfigRewriter.Context[StrT]) -> StrT:
+        v = ctx.obj
+        if (fn := self._fn) is not None:
+            if not ctx.raw:
+                v = fn(v)  # type: ignore
+        return type(v)(v)
+
+
+##
+
+
+def format_config_strings(v: T, rpl: ta.Mapping[str, str]) -> T:
+    def fn(v):
+        return v.format(**rpl)
+
+    return StringConfigRewriter(fn)(v)

omlish/configs/types.py

@@ -0,0 +1,9 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import typing as ta
+
+
+ConfigMap = ta.Mapping[str, ta.Any]
+
+
+#

omlish/formats/__init__.py

@@ -0,0 +1,4 @@
+"""
+TODO:
+ - csv
+"""

omlish/formats/ini/codec.py

@@ -0,0 +1,26 @@
+import configparser
+
+from ..codecs import make_object_lazy_loaded_codec
+from ..codecs import make_str_object_codec
+from .sections import IniSectionSettingsMap
+from .sections import extract_ini_sections
+from .sections import render_ini_sections
+
+
+##
+
+
+def loads(s: str) -> IniSectionSettingsMap:
+    cp = configparser.ConfigParser()
+    cp.read_string(s)
+    return extract_ini_sections(cp)
+
+
+def dumps(sm: IniSectionSettingsMap) -> str:
+    return render_ini_sections(sm)
+
+
+INI_CODEC = make_str_object_codec('ini', dumps, loads)
+
+# @omlish-manifest
+_INI_LAZY_CODEC = make_object_lazy_loaded_codec(__name__, 'INI_CODEC', INI_CODEC)

omlish/formats/ini/sections.py

@@ -0,0 +1,45 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import configparser
+import io
+import typing as ta
+
+
+IniSectionSettingsMap = ta.Mapping[str, ta.Mapping[str, ta.Union[str, ta.Sequence[str]]]]  # ta.TypeAlias
+
+
+##
+
+
+def extract_ini_sections(cp: configparser.ConfigParser) -> IniSectionSettingsMap:
+    config_dct: ta.Dict[str, ta.Any] = {}
+    for sec in cp.sections():
+        cd = config_dct
+        for k in sec.split('.'):
+            cd = cd.setdefault(k, {})
+        cd.update(cp.items(sec))
+    return config_dct
+
+
+##
+
+
+def render_ini_sections(
+        settings_by_section: IniSectionSettingsMap,
+) -> str:
+    out = io.StringIO()
+
+    for i, (section, settings) in enumerate(settings_by_section.items()):
+        if i:
+            out.write('\n')
+
+        out.write(f'[{section}]\n')
+
+        for k, v in settings.items():
+            if isinstance(v, str):
+                out.write(f'{k}={v}\n')
+            else:
+                for vv in v:
+                    out.write(f'{k}={vv}\n')
+
+    return out.getvalue()

omlish/formats/{toml.py → toml/codec.py}

@@ -1,7 +1,7 @@
 import tomllib
 
-from .codecs import make_object_lazy_loaded_codec
-from .codecs import make_str_object_codec
+from ..codecs import make_object_lazy_loaded_codec
+from ..codecs import make_str_object_codec
 
 
 ##