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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev193'
-__revision__ = 'abb15c34774729bc05f56f8b60e9ee7fdc3b3526'
+__version__ = '0.0.0.dev194'
+__revision__ = '39cfe872573628af34684eb1ec41a0ccb127ad0f'
 
 
 #

omlish/configs/formats.py

@@ -0,0 +1,247 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+Notes:
+ - necessarily string-oriented
+ - single file, as this is intended to be amalg'd and thus all included anyway
+
+TODO:
+ - ConfigDataMapper? to_map -> ConfigMap?
+ - nginx ?
+ - raw ?
+"""
+import abc
+import collections.abc
+import configparser
+import dataclasses as dc
+import json
+import os.path
+import typing as ta
+
+from ..formats.ini.sections import IniSectionSettingsMap
+from ..formats.ini.sections import extract_ini_sections
+from ..formats.ini.sections import render_ini_sections
+from ..formats.toml.parser import toml_loads
+from ..formats.toml.writer import TomlWriter
+from ..lite.check import check
+from ..lite.json import json_dumps_pretty
+from .types import ConfigMap
+
+
+T = ta.TypeVar('T')
+ConfigDataT = ta.TypeVar('ConfigDataT', bound='ConfigData')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ConfigData(abc.ABC):  # noqa
+    @abc.abstractmethod
+    def as_map(self) -> ConfigMap:
+        raise NotImplementedError
+
+
+#
+
+
+class ConfigLoader(abc.ABC, ta.Generic[ConfigDataT]):
+    @property
+    def file_exts(self) -> ta.Sequence[str]:
+        return ()
+
+    def match_file(self, n: str) -> bool:
+        return '.' in n and n.split('.')[-1] in check.not_isinstance(self.file_exts, str)
+
+    #
+
+    def load_file(self, p: str) -> ConfigDataT:
+        with open(p) as f:
+            return self.load_str(f.read())
+
+    @abc.abstractmethod
+    def load_str(self, s: str) -> ConfigDataT:
+        raise NotImplementedError
+
+
+#
+
+
+class ConfigRenderer(abc.ABC, ta.Generic[ConfigDataT]):
+    @property
+    @abc.abstractmethod
+    def data_cls(self) -> ta.Type[ConfigDataT]:
+        raise NotImplementedError
+
+    def match_data(self, d: ConfigDataT) -> bool:
+        return isinstance(d, self.data_cls)
+
+    #
+
+    @abc.abstractmethod
+    def render(self, d: ConfigDataT) -> str:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ObjConfigData(ConfigData, abc.ABC):
+    obj: ta.Any
+
+    def as_map(self) -> ConfigMap:
+        return check.isinstance(self.obj, collections.abc.Mapping)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class JsonConfigData(ObjConfigData):
+    pass
+
+
+class JsonConfigLoader(ConfigLoader[JsonConfigData]):
+    file_exts = ('json',)
+
+    def load_str(self, s: str) -> JsonConfigData:
+        return JsonConfigData(json.loads(s))
+
+
+class JsonConfigRenderer(ConfigRenderer[JsonConfigData]):
+    data_cls = JsonConfigData
+
+    def render(self, d: JsonConfigData) -> str:
+        return json_dumps_pretty(d.obj)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TomlConfigData(ObjConfigData):
+    pass
+
+
+class TomlConfigLoader(ConfigLoader[TomlConfigData]):
+    file_exts = ('toml',)
+
+    def load_str(self, s: str) -> TomlConfigData:
+        return TomlConfigData(toml_loads(s))
+
+
+class TomlConfigRenderer(ConfigRenderer[TomlConfigData]):
+    data_cls = TomlConfigData
+
+    def render(self, d: TomlConfigData) -> str:
+        return TomlWriter.write_str(d.obj)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class YamlConfigData(ObjConfigData):
+    pass
+
+
+class YamlConfigLoader(ConfigLoader[YamlConfigData]):
+    file_exts = ('yaml', 'yml')
+
+    def load_str(self, s: str) -> YamlConfigData:
+        return YamlConfigData(__import__('yaml').safe_load(s))
+
+
+class YamlConfigRenderer(ConfigRenderer[YamlConfigData]):
+    data_cls = YamlConfigData
+
+    def render(self, d: YamlConfigData) -> str:
+        return __import__('yaml').safe_dump(d.obj)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class IniConfigData(ConfigData):
+    sections: IniSectionSettingsMap
+
+    def as_map(self) -> ConfigMap:
+        return self.sections
+
+
+class IniConfigLoader(ConfigLoader[IniConfigData]):
+    file_exts = ('ini',)
+
+    def load_str(self, s: str) -> IniConfigData:
+        cp = configparser.ConfigParser()
+        cp.read_string(s)
+        return IniConfigData(extract_ini_sections(cp))
+
+
+class IniConfigRenderer(ConfigRenderer[IniConfigData]):
+    data_cls = IniConfigData
+
+    def render(self, d: IniConfigData) -> str:
+        return render_ini_sections(d.sections)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SwitchedConfigFileLoader:
+    loaders: ta.Sequence[ConfigLoader]
+    default: ta.Optional[ConfigLoader] = None
+
+    def load_file(self, p: str) -> ConfigData:
+        n = os.path.basename(p)
+
+        for l in self.loaders:
+            if l.match_file(n):
+                return l.load_file(p)
+
+        if (d := self.default) is not None:
+            return d.load_file(p)
+
+        raise NameError(n)
+
+
+DEFAULT_CONFIG_LOADERS: ta.Sequence[ConfigLoader] = [
+    JsonConfigLoader(),
+    TomlConfigLoader(),
+    YamlConfigLoader(),
+    IniConfigLoader(),
+]
+
+DEFAULT_CONFIG_LOADER: ConfigLoader = JsonConfigLoader()
+
+DEFAULT_CONFIG_FILE_LOADER = SwitchedConfigFileLoader(
+    loaders=DEFAULT_CONFIG_LOADERS,
+    default=DEFAULT_CONFIG_LOADER,
+)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SwitchedConfigRenderer:
+    renderers: ta.Sequence[ConfigRenderer]
+
+    def render(self, d: ConfigData) -> str:
+        for r in self.renderers:
+            if r.match_data(d):
+                return r.render(d)
+        raise TypeError(d)
+
+
+DEFAULT_CONFIG_RENDERERS: ta.Sequence[ConfigRenderer] = [
+    JsonConfigRenderer(),
+    TomlConfigRenderer(),
+    YamlConfigRenderer(),
+    IniConfigRenderer(),
+]
+
+DEFAULT_CONFIG_RENDERER = SwitchedConfigRenderer(DEFAULT_CONFIG_RENDERERS)

omlish/configs/nginx.py

@@ -0,0 +1,72 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+See:
+ - https://nginx.org/en/docs/dev/development_guide.html
+ - https://nginx.org/en/docs/dev/development_guide.html#config_directives
+ - https://nginx.org/en/docs/example.html
+"""
+import collections.abc
+import dataclasses as dc
+import typing as ta
+
+from ..lite.check import check
+from ..text.indent import IndentWriter
+
+
+@dc.dataclass()
+class NginxConfigItems:
+    lst: ta.List['NginxConfigItem']
+
+    @classmethod
+    def of(cls, obj: ta.Any) -> 'NginxConfigItems':
+        if isinstance(obj, NginxConfigItems):
+            return obj
+        return cls([NginxConfigItem.of(e) for e in check.isinstance(obj, list)])
+
+
+@dc.dataclass()
+class NginxConfigItem:
+    name: str
+    args: ta.Optional[ta.List[str]] = None
+    block: ta.Optional[NginxConfigItems] = None
+
+    @classmethod
+    def of(cls, obj: ta.Any) -> 'NginxConfigItem':
+        if isinstance(obj, NginxConfigItem):
+            return obj
+        args = check.isinstance(check.not_isinstance(obj, str), collections.abc.Sequence)
+        name, args = check.isinstance(args[0], str), args[1:]
+        if args and not isinstance(args[-1], str):
+            block, args = NginxConfigItems.of(args[-1]), args[:-1]
+        else:
+            block = None
+        return NginxConfigItem(name, [check.isinstance(e, str) for e in args], block=block)
+
+
+def render_nginx_config(wr: IndentWriter, obj: ta.Any) -> None:
+    if isinstance(obj, NginxConfigItem):
+        wr.write(obj.name)
+        for e in obj.args or ():
+            wr.write(' ')
+            wr.write(e)
+        if obj.block:
+            wr.write(' {\n')
+            with wr.indent():
+                render_nginx_config(wr, obj.block)
+            wr.write('}\n')
+        else:
+            wr.write(';\n')
+
+    elif isinstance(obj, NginxConfigItems):
+        for e2 in obj.lst:
+            render_nginx_config(wr, e2)
+
+    else:
+        raise TypeError(obj)
+
+
+def render_nginx_config_str(obj: ta.Any) -> str:
+    iw = IndentWriter()
+    render_nginx_config(iw, obj)
+    return iw.getvalue()

omlish/configs/{flattening.py → processing/flattening.py}

@@ -3,7 +3,7 @@
 import abc
 import typing as ta
 
-from ..lite.check import check
+from ...lite.check import check
 
 
 K = ta.TypeVar('K')

omlish/configs/processing/inheritance.py

@@ -0,0 +1,58 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+TODO:
+ - custom merging by key - replace, append, setdefault, equality enforcement, ...
+ - better handling of 'None' as signal to replace or not
+ - remove inherited
+"""
+import typing as ta
+
+from ..types import ConfigMap
+
+
+##
+
+
+def build_config_inherited_values(
+        m: ta.Mapping[str, ConfigMap],
+        *,
+        inherits_key: str = 'inherits',
+) -> ta.Dict[str, ConfigMap]:
+    done: ta.Dict[str, ConfigMap] = {}
+
+    def rec(mk: str) -> ta.Mapping[str, ConfigMap]:
+        try:
+            return done[mk]
+        except KeyError:
+            pass
+
+        cur = m[mk]
+        try:
+            inh_seq = cur[inherits_key]
+        except KeyError:
+            done[mk] = cur
+            return cur
+
+        new = dict(cur)
+        for inh in inh_seq:
+            inh_dct = rec(inh)
+            new.update({
+                k: v
+                for k, v in inh_dct.items()
+                if v is not None
+                and cur.get(k) is None
+            })
+
+        out = {
+            k: v
+            for k, v in new.items()
+            if k != inherits_key
+        }
+
+        done[mk] = out
+        return out
+
+    for mk in m:
+        rec(mk)
+    return done

omlish/configs/processing/matching.py

@@ -0,0 +1,53 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import dataclasses as dc
+import functools
+import typing as ta
+
+from ...lite.check import check
+from .rewriting import ConfigRewriter
+from .rewriting import ConfigRewriterPath
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class MatchingConfigRewriter(ConfigRewriter):
+    def __init__(
+            self,
+            fn: ta.Callable[[ta.Any], ta.Any],
+            paths: ta.Iterable[ConfigRewriterPath],
+            *,
+            recurse: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._paths = frozenset(check.isinstance(p, tuple) for p in paths)
+        self._recurse = recurse
+
+    def rewrite(self, ctx: ConfigRewriter.Context[T]) -> T:
+        if ctx.path in self._paths:
+            no = self._fn(ctx.obj)
+            if not self._recurse:
+                return no
+            ctx = dc.replace(ctx, obj=no)
+
+        return super().rewrite(ctx)
+
+
+def matched_config_rewrite(
+        fn: ta.Callable[[ta.Any], ta.Any],
+        obj: T,
+        *paths: ConfigRewriterPath,
+        recurse: bool = False,
+        **kwargs: ta.Any,
+) -> T:
+    return MatchingConfigRewriter(
+        functools.partial(fn, **kwargs),
+        paths,
+        recurse=recurse,
+    )(obj)

omlish/configs/processing/names.py

@@ -0,0 +1,50 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+usecase: supervisor process groups
+"""
+import typing as ta
+
+from ...lite.check import check
+from ..types import ConfigMap
+
+
+##
+
+
+def build_config_named_children(
+        o: ta.Union[
+            ta.Sequence[ConfigMap],
+            ta.Mapping[str, ConfigMap],
+            None,
+        ],
+        *,
+        name_key: str = 'name',
+) -> ta.Optional[ta.Sequence[ConfigMap]]:
+    if o is None:
+        return None
+
+    lst: ta.List[ConfigMap] = []
+    if isinstance(o, ta.Mapping):
+        for k, v in o.items():
+            check.isinstance(v, ta.Mapping)
+            if name_key in v:
+                n = v[name_key]
+                if k != n:
+                    raise KeyError(f'Given names do not match: {n} != {k}')
+                lst.append(v)
+            else:
+                lst.append({name_key: k, **v})
+
+    else:
+        check.not_isinstance(o, str)
+        lst.extend(o)
+
+    seen = set()
+    for d in lst:
+        n = d['name']
+        if n in d:
+            raise KeyError(f'Duplicate name: {n}')
+        seen.add(n)
+
+    return lst

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

@@ -1,5 +1,4 @@
 """
 TODO:
  - csv
- - ini
 """

omlish/formats/toml/writer.py

@@ -1,5 +1,6 @@
 # @omlish-lite
 import dataclasses as dc
+import io
 import string
 import typing as ta
 
@@ -113,3 +114,11 @@ class TomlWriter:
                 self.write_array(obj)
         else:
             raise TypeError(obj)
+
+    #
+
+    @classmethod
+    def write_str(cls, obj: ta.Any) -> str:
+        out = io.StringIO()
+        cls(out).write_value(obj)
+        return out.getvalue()

omlish/lite/configs.py

@@ -0,0 +1,38 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from ..configs.formats import DEFAULT_CONFIG_FILE_LOADER
+from ..configs.types import ConfigMap
+from .marshal import OBJ_MARSHALER_MANAGER
+from .marshal import ObjMarshalerManager
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def load_config_file_obj(
+        f: str,
+        cls: ta.Type[T],
+        *,
+        prepare: ta.Union[
+            ta.Callable[[ConfigMap], ConfigMap],
+            ta.Iterable[ta.Callable[[ConfigMap], ConfigMap]],
+        ] = (),
+        msh: ObjMarshalerManager = OBJ_MARSHALER_MANAGER,
+) -> T:
+    config_data = DEFAULT_CONFIG_FILE_LOADER.load_file(f)
+
+    config_dct = config_data.as_map()
+
+    if prepare is not None:
+        if isinstance(prepare, ta.Iterable):
+            pfs = list(prepare)
+        else:
+            pfs = [prepare]
+        for pf in pfs:
+            config_dct = pf(config_dct)
+
+    return msh.unmarshal_obj(config_dct, cls)

omlish/text/glyphsplit.py

@@ -97,3 +97,16 @@ glyph_split_parens = _PAREN_GLYPH_SPLITTER.split
 glyph_split_braces = _BRACE_GLYPH_SPLITTER.split
 glyph_split_brackets = _BRACKET_GLYPH_SPLITTER.split
 glyph_split_angle_brackets = _ANGLE_BRACKET_GLYPH_SPLITTER.split
+
+
+def glyph_split_interpolate(
+        split_fn: ta.Callable[[str], ta.Sequence[ta.Union[GlyphSplitMatch, str]]],
+        dct: ta.Mapping[str, str],
+        s: str,
+) -> str:
+    if not s:
+        return s
+    sps = split_fn(s)
+    if len(sps) == 1 and isinstance(sps[0], str):
+        return sps[0]
+    return ''.join(dct[p.s] if isinstance(p, GlyphSplitMatch) else p for p in sps)

{omlish-0.0.0.dev193.dist-info → omlish-0.0.0.dev194.dist-info}/METADATA

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

{omlish-0.0.0.dev193.dist-info → omlish-0.0.0.dev194.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=dyIpveH7Z8OnQp2pTn6NVv7LCDXVrozJWAzbk8PBavg,7950
-omlish/__about__.py,sha256=8ZHxg4DUtn_y7pls_IM3xNDk_hcPGBh1tnkB36CBP5U,3409
+omlish/__about__.py,sha256=EGlq5fZGiyJg2x9ba9tOUhbLf6OjV9lr0mNkhwX1DnU,3409
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -151,8 +151,16 @@ omlish/concurrent/futures.py,sha256=J2s9wYURUskqRJiBbAR0PNEAp1pXbIMYldOVBTQduQY,
 omlish/concurrent/threadlets.py,sha256=JfirbTDJgy9Ouokz_VmHeAAPS7cih8qMUJrN-owwXD4,2423
 omlish/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/configs/classes.py,sha256=GLbB8xKjHjjoUQRCUQm3nEjM8z1qNTx9gPV7ODSt5dg,1317
-omlish/configs/flattening.py,sha256=t29dgCTcwrgvOEuxIxLf7FgZhOpH2Z72xIRHglXbxUI,5020
-omlish/configs/strings.py,sha256=Ho92yy3Ex_-FoUTBuUcRF_tJ-iE9kFFa5oOqnGtCRZg,2662
+omlish/configs/formats.py,sha256=RJw4Rzp7vlTd5YyAvpAoruQnk45v8dGPtPWwqH7aYyE,5301
+omlish/configs/nginx.py,sha256=XuX9yyb0_MwkJ8esKiMS9gFkqHUPza_uCprhnWykNy8,2051
+omlish/configs/types.py,sha256=t5_32MVRSKxbxor1hl1wRGKYm75F6Atisd_RYsN5ELU,103
+omlish/configs/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/configs/processing/flattening.py,sha256=1duZH5zbrGuoYqaJco5LN5qx6e76QP5pHbIyItkQsFY,5021
+omlish/configs/processing/inheritance.py,sha256=lFD8eWRE0cG0Z3-eCu7pMsP2skWhUNaoAtWi9fNfn8k,1218
+omlish/configs/processing/matching.py,sha256=JMS9r58pMCBbpewOhPY5oPtBu3uD6z6YBfZq4jnLwBE,1236
+omlish/configs/processing/names.py,sha256=weHmaTclzgM9lUn3aBtw-kwZ3mc2N-CZlFg3Kd_UsKo,1093
+omlish/configs/processing/rewriting.py,sha256=v7PfHtuTn5v_5Y6Au7oMN2Z0nxAMy1iYyO5CXnTvZhs,4226
+omlish/configs/processing/strings.py,sha256=qFS2oh6z02IaM_q4lTKLdufzkJqAJ6J-Qjrz5S-QJoM,826
 omlish/dataclasses/__init__.py,sha256=AHo-tN5V_b_VYFUF7VFRmuHrjZBXS1WytRAj061MUTA,1423
 omlish/dataclasses/utils.py,sha256=lcikCPiiX5Giu0Kb1hP18loZjmm_Z9D-XtJ-ZlHq9iM,3793
 omlish/dataclasses/impl/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
@@ -209,7 +217,7 @@ omlish/docker/detect.py,sha256=Qrdbosm2wJkxKDuy8gaGmbQoxk4Wnp1HJjAEz58NA8Y,614
 omlish/docker/hub.py,sha256=7LIuJGdA-N1Y1dmo50ynKM1KUTcnQM_5XbtPbdT_QLU,3940
 omlish/docker/manifests.py,sha256=LR4FpOGNUT3bZQ-gTjB6r_-1C3YiG30QvevZjrsVUQM,7068
 omlish/docker/timebomb.py,sha256=A_pgIDaXKsQwPiikrCTgIJl91gwYqkPGFY6j-Naq07Q,342
-omlish/formats/__init__.py,sha256=KC-AiWm95O6kXVW4cRUnq8WnybKnE6lR9sf_i2DuV4o,28
+omlish/formats/__init__.py,sha256=T0AG1gFnqQ5JiHN0UPQjQ-7g5tnxMIG-mgOvMYExYAM,21
 omlish/formats/cbor.py,sha256=o_Hbe4kthO9CeXK-FySrw0dHVlrdyTo2Y8PpGRDfZ3c,514
 omlish/formats/cloudpickle.py,sha256=16si4yUp_pAdDWGECAWf6HLA2PwSANGGgDoMLGZUem8,579
 omlish/formats/codecs.py,sha256=6AbKIz_gl_om36-7qsutybYzK8cJP3LzwC9YJlwCPOA,1590
@@ -248,7 +256,7 @@ omlish/formats/json/stream/render.py,sha256=NtmDsN92xZi5dkgSSuMeMXMAiJblmjz1arB4
 omlish/formats/toml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/formats/toml/codec.py,sha256=5HFGWEPd9IFxPlRMRheX8FEDlRIzLe1moHEOj2_PFKU,342
 omlish/formats/toml/parser.py,sha256=3QN3rqdJ_zlHfFtsDn-A9pl-BTwdVMUUpUV5-lGWCKc,29342
-omlish/formats/toml/writer.py,sha256=KyT1PnAQqx-uVcb0vTPzt-A9N-WfDiiaokg4kUeEXHk,3055
+omlish/formats/toml/writer.py,sha256=HIp6XvriXaPTLqyLe-fkIiEf1Pyhsp0TcOg5rFBpO3g,3226
 omlish/funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/funcs/genmachine.py,sha256=EY2k-IFNKMEmHo9CmGRptFvhEMZVOWzZhn0wdQGeaFM,2476
 omlish/funcs/match.py,sha256=gMLZn1enNiFvQaWrQubY300M1BrmdKWzeePihBS7Ywc,6153
@@ -383,6 +391,7 @@ omlish/lifecycles/transitions.py,sha256=qQtFby-h4VzbvgaUqT2NnbNumlcOx9FVVADP9t83
 omlish/lite/__init__.py,sha256=ISLhM4q0LR1XXTCaHdZOZxBRyIsoZqYm4u0bf1BPcVk,148
 omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
 omlish/lite/check.py,sha256=0PD-GKtaDqDX6jU5KbzbMvH-vl6jH82xgYfplmfTQkg,12941
+omlish/lite/configs.py,sha256=Ev_19sbII67pTWzInYjYqa9VyTiZBvyjhZqyG8TtufE,908
 omlish/lite/contextmanagers.py,sha256=m9JO--p7L7mSl4cycXysH-1AO27weDKjP3DZG61cwwM,1683
 omlish/lite/dataclasses.py,sha256=M6UD4VwGo0Ky7RNzKWbO0IOy7iBZVCIbTiC6EYbFnX8,1035
 omlish/lite/inject.py,sha256=qBUftFeXMiRgANYbNS2e7TePMYyFAcuLgsJiLyMTW5o,28769
@@ -581,14 +590,14 @@ omlish/testing/pytest/plugins/utils.py,sha256=L5C622UXcA_AUKDcvyh5IMiRfqSGGz0Mcd
 omlish/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/text/asdl.py,sha256=AS3irh-sag5pqyH3beJif78PjCbOaFso1NeKq-HXuTs,16867
 omlish/text/delimit.py,sha256=ubPXcXQmtbOVrUsNh5gH1mDq5H-n1y2R4cPL5_DQf68,4928
-omlish/text/glyphsplit.py,sha256=vN6TgnMONCTsHL8_lDaOfFmd5j_JVxOV_nRre4SENF8,3420
+omlish/text/glyphsplit.py,sha256=kqqjglRdxGo0czYZxOz9Vi8aBmVsCOq8h6lPwRA5xe0,3803
 omlish/text/indent.py,sha256=XixaVnk9bvtBlH0n_cwN6yS5IyfrTWpe_alfu3_saLY,1341
 omlish/text/minja.py,sha256=KAmZ2POcLcxwF4DPKxdWa16uWxXmVz1UnJXLSwt4oZo,5761
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev193.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev193.dist-info/METADATA,sha256=CurOKNHEhxcUbUQtXrRsaxGfunrIIFaJO-ZJiGOmAg4,4264
-omlish-0.0.0.dev193.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev193.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev193.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev193.dist-info/RECORD,,
+omlish-0.0.0.dev194.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev194.dist-info/METADATA,sha256=nhNsVPo6hNygJ8DxnRbJE-iqP-emALofRYUylUQkyJc,4264
+omlish-0.0.0.dev194.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev194.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev194.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev194.dist-info/RECORD,,

omlish/configs/strings.py

@@ -1,96 +0,0 @@
-"""
-TODO:
- - reflecty generalized rewriter, obviously..
- - env vars
- - coalescing - {$FOO|$BAR|baz}
-"""
-import collections.abc
-import typing as ta
-
-from .. import dataclasses as dc
-from .. import lang
-from ..text import glyphsplit
-
-
-T = ta.TypeVar('T')
-
-
-class InterpolateStringsMetadata(lang.Marker):
-    pass
-
-
-@dc.field_modifier
-def secret_or_key_field(f: dc.Field) -> dc.Field:
-    return dc.update_field_metadata(f, {
-        InterpolateStringsMetadata: True,
-    })
-
-
-@dc.field_modifier
-def interpolate_field(f: dc.Field) -> dc.Field:
-    return dc.update_field_metadata(f, {InterpolateStringsMetadata: True})
-
-
-class StringRewriter:
-    def __init__(self, fn: ta.Callable[[str], str]) -> None:
-        super().__init__()
-        self._fn = fn
-
-    def __call__(self, v: T, *, _soft: bool = False) -> T:
-        if v is None:
-            return None  # type: ignore
-
-        if dc.is_dataclass(v):
-            kw = {}
-            for f in dc.fields(v):
-                fv = getattr(v, f.name)
-                nfv = self(fv, _soft=not f.metadata.get(InterpolateStringsMetadata))
-                if fv is not nfv:
-                    kw[f.name] = nfv
-            if not kw:
-                return v  # type: ignore
-            return dc.replace(v, **kw)
-
-        if isinstance(v, str):
-            if not _soft:
-                v = self._fn(v)  # type: ignore
-            return v  # type: ignore
-
-        if isinstance(v, lang.BUILTIN_SCALAR_ITERABLE_TYPES):
-            return v  # type: ignore
-
-        if isinstance(v, collections.abc.Mapping):
-            nm = []
-            b = False
-            for mk, mv in v.items():
-                nk, nv = self(mk, _soft=_soft), self(mv, _soft=_soft)
-                nm.append((nk, nv))
-                b |= nk is not mk or nv is not mv
-            if not b:
-                return v  # type: ignore
-            return v.__class__(nm)  # type: ignore
-
-        if isinstance(v, (collections.abc.Sequence, collections.abc.Set)):
-            nl = []
-            b = False
-            for le in v:
-                ne = self(le, _soft=_soft)
-                nl.append(ne)
-                b |= ne is not le
-            if not b:
-                return v  # type: ignore
-            return v.__class__(nl)  # type: ignore
-
-        return v
-
-
-def interpolate_strings(v: T, rpl: ta.Mapping[str, str]) -> T:
-    def fn(v):
-        if not v:
-            return v
-        sps = glyphsplit.glyph_split_braces(v)
-        if len(sps) == 1 and isinstance(sps[0], str):
-            return sps[0]
-        return ''.join(rpl[p.s] if isinstance(p, glyphsplit.GlyphSplitMatch) else p for p in sps)
-
-    return StringRewriter(fn)(v)