omlish 0.0.0.dev193__tar.gz → 0.0.0.dev194__tar.gz

{omlish-0.0.0.dev193/omlish.egg-info → omlish-0.0.0.dev194}/PKG-INFO

@@ -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 → omlish-0.0.0.dev194}/omlish/__about__.py

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

omlish-0.0.0.dev194/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-0.0.0.dev194/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-0.0.0.dev193/omlish/configs → omlish-0.0.0.dev194/omlish/configs/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-0.0.0.dev194/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-0.0.0.dev194/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-0.0.0.dev194/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-0.0.0.dev194/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-0.0.0.dev194/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-0.0.0.dev194/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-0.0.0.dev193 → omlish-0.0.0.dev194}/omlish/formats/__init__.py

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