omlish 0.0.0.dev192__py3-none-any.whl → 0.0.0.dev193__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.dev193'
+__revision__ = 'abb15c34774729bc05f56f8b60e9ee7fdc3b3526'
 
 
 #

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/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/strings.py

@@ -88,9 +88,9 @@ def interpolate_strings(v: T, rpl: ta.Mapping[str, str]) -> T:
     def fn(v):
         if not v:
             return v
-        sps = glyphsplit.split_braces(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.GlyphMatch) else p for p in sps)
+        return ''.join(rpl[p.s] if isinstance(p, glyphsplit.GlyphSplitMatch) else p for p in sps)
 
     return StringRewriter(fn)(v)

omlish/formats/__init__.py

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

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
 
 
 ##