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

omlish/.manifests.json

@@ -51,6 +51,20 @@
       }
     }
   },
+  {
+    "module": ".formats.ini.codec",
+    "attr": "_INI_LAZY_CODEC",
+    "file": "omlish/formats/ini/codec.py",
+    "line": 25,
+    "value": {
+      "$.codecs.base.LazyLoadedCodec": {
+        "mod_name": "omlish.formats.ini.codec",
+        "attr_name": "INI_CODEC",
+        "name": "ini",
+        "aliases": null
+      }
+    }
+  },
   {
     "module": ".formats.json.codecs",
     "attr": "_JSON_LAZY_CODEC",
@@ -136,13 +150,13 @@
     }
   },
   {
-    "module": ".formats.toml",
+    "module": ".formats.toml.codec",
     "attr": "_TOML_LAZY_CODEC",
-    "file": "omlish/formats/toml.py",
+    "file": "omlish/formats/toml/codec.py",
     "line": 16,
     "value": {
       "$.codecs.base.LazyLoadedCodec": {
-        "mod_name": "omlish.formats.toml",
+        "mod_name": "omlish.formats.toml.codec",
         "attr_name": "TOML_CODEC",
         "name": "toml",
         "aliases": null

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev192'
-__revision__ = '75df1ba4f1cbe21d9930a1f467e7e99c5c23c621'
+__version__ = '0.0.0.dev194'
+__revision__ = '39cfe872573628af34684eb1ec41a0ccb127ad0f'
 
 
 #

omlish/codecs/base.py

@@ -1,6 +1,8 @@
 """
 TODO:
  - bytes-like - bytearray, memoryview
+ - FileCodec
+ - implement options
 """
 import abc
 import typing as ta

omlish/configs/__init__.py

@@ -1,5 +0,0 @@
-from .classes import (  # noqa
-    Config,
-    Configurable,
-    get_impl,
-)

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}

@@ -1,32 +1,33 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 import abc
-import itertools
 import typing as ta
 
-from .. import check
-from .. import lang
+from ...lite.check import check
 
 
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
-StrMap = ta.Mapping[str, ta.Any]
 
 
-class _MISSING(lang.Marker):
-    pass
+##
 
 
-class Flattening:
-
+class ConfigFlattening:
     DEFAULT_DELIMITER = '.'
     DEFAULT_INDEX_OPEN = '('
     DEFAULT_INDEX_CLOSE = ')'
 
+    class _MISSING:
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
     def __init__(
             self,
             *,
-            delimiter=DEFAULT_DELIMITER,
-            index_open=DEFAULT_INDEX_OPEN,
-            index_close=DEFAULT_INDEX_CLOSE,
+            delimiter: str = DEFAULT_DELIMITER,
+            index_open: str = DEFAULT_INDEX_OPEN,
+            index_close: str = DEFAULT_INDEX_CLOSE,
     ) -> None:
         super().__init__()
 
@@ -34,8 +35,8 @@ class Flattening:
         self._index_open = check.not_empty(index_open)
         self._index_close = check.not_empty(index_close)
 
-    def flatten(self, unflattened: StrMap) -> StrMap:
-        def rec(prefix: list[str], value: ta.Any) -> None:
+    def flatten(self, unflattened: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, ta.Any]:
+        def rec(prefix: ta.List[str], value: ta.Any) -> None:
             if isinstance(value, dict):
                 for k, v in value.items():
                     rec([*prefix, k], v)
@@ -53,8 +54,7 @@ class Flattening:
         rec([], unflattened)
         return ret
 
-    class UnflattenNode(lang.Abstract, ta.Generic[K]):
-
+    class UnflattenNode(abc.ABC, ta.Generic[K]):
         @abc.abstractmethod
         def get(self, key: K) -> ta.Any:
             raise NotImplementedError
@@ -65,7 +65,7 @@ class Flattening:
 
         def setdefault(self, key: K, supplier: ta.Callable[[], V]) -> V:
             ret = self.get(key)
-            if ret is _MISSING:
+            if ret is ConfigFlattening._MISSING:
                 ret = supplier()
                 self.put(key, ret)
             return ret
@@ -77,50 +77,48 @@ class Flattening:
         @staticmethod
         def maybe_build(value: ta.Any) -> ta.Any:
             check.not_none(value)
-            return value.build() if isinstance(value, Flattening.UnflattenNode) else value
+            return value.build() if isinstance(value, ConfigFlattening.UnflattenNode) else value
 
     class UnflattenDict(UnflattenNode[str]):
-
         def __init__(self) -> None:
             super().__init__()
 
             self._dict: dict[str, ta.Any] = {}
 
         def get(self, key: str) -> ta.Any:
-            return self._dict.get(key, _MISSING)
+            return self._dict.get(key, ConfigFlattening._MISSING)
 
         def put(self, key: str, value: ta.Any) -> None:
             check.arg(key not in self._dict)
             self._dict[key] = value
 
         def build(self) -> ta.Any:
-            return {k: Flattening.UnflattenNode.maybe_build(v) for k, v in self._dict.items()}
+            return {k: ConfigFlattening.UnflattenNode.maybe_build(v) for k, v in self._dict.items()}
 
     class UnflattenList(UnflattenNode[int]):
-
         def __init__(self) -> None:
             super().__init__()
 
-            self._list: list[ta.Any] = []
+            self._list: ta.List[ta.Any] = []
 
         def get(self, key: int) -> ta.Any:
             check.arg(key >= 0)
-            return self._list[key] if key < len(self._list) else _MISSING
+            return self._list[key] if key < len(self._list) else ConfigFlattening._MISSING
 
         def put(self, key: int, value: ta.Any) -> None:
             check.arg(key >= 0)
             if key >= len(self._list):
-                self._list.extend([_MISSING] * (key - len(self._list) + 1))
-            check.arg(self._list[key] is _MISSING)
+                self._list.extend([ConfigFlattening._MISSING] * (key - len(self._list) + 1))
+            check.arg(self._list[key] is ConfigFlattening._MISSING)
             self._list[key] = value
 
         def build(self) -> ta.Any:
-            return [Flattening.UnflattenNode.maybe_build(e) for e in self._list]
+            return [ConfigFlattening.UnflattenNode.maybe_build(e) for e in self._list]
 
-    def unflatten(self, flattened: StrMap) -> StrMap:
-        root = Flattening.UnflattenDict()
+    def unflatten(self, flattened: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, ta.Any]:
+        root = ConfigFlattening.UnflattenDict()
 
-        def split_keys(fkey: str) -> ta.Iterable[str | int]:
+        def split_keys(fkey: str) -> ta.Iterable[ta.Union[str, int]]:
             for part in fkey.split(self._delimiter):
                 if self._index_open in part:
                     check.state(part.endswith(self._index_close))
@@ -134,13 +132,13 @@ class Flattening:
                     yield part
 
         for fk, v in flattened.items():
-            node: Flattening.UnflattenNode = root
+            node: ConfigFlattening.UnflattenNode = root
             fks = list(split_keys(fk))
-            for key, nkey in itertools.pairwise(fks):
+            for key, nkey in zip(fks, fks[1:]):  # noqa
                 if isinstance(nkey, str):
-                    node = node.setdefault(key, Flattening.UnflattenDict)
+                    node = node.setdefault(key, ConfigFlattening.UnflattenDict)
                 elif isinstance(nkey, int):
-                    node = node.setdefault(key, Flattening.UnflattenList)
+                    node = node.setdefault(key, ConfigFlattening.UnflattenList)
                 else:
                     raise TypeError(key)
             node.put(fks[-1], v)

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