omdev 0.0.0.dev194__tar.gz → 0.0.0.dev196__tar.gz

{omdev-0.0.0.dev194/omdev.egg-info → omdev-0.0.0.dev196}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omdev
-Version: 0.0.0.dev194
+Version: 0.0.0.dev196
 Summary: omdev
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev194
+Requires-Dist: omlish==0.0.0.dev196
 Provides-Extra: all
 Requires-Dist: black~=24.10; extra == "all"
 Requires-Dist: pycparser~=2.22; extra == "all"

{omdev-0.0.0.dev194 → omdev-0.0.0.dev196}/omdev/.manifests.json

@@ -231,7 +231,7 @@
     "module": ".tools.cloc",
     "attr": "_CLI_MODULE",
     "file": "omdev/tools/cloc.py",
-    "line": 194,
+    "line": 199,
     "value": {
       "$.cli.types.CliModule": {
         "cmd_name": "cloc",

{omdev-0.0.0.dev194 → omdev-0.0.0.dev196}/omdev/git/subtrees.py

@@ -15,7 +15,7 @@ class GitSubtreeCloner:
 
     # _: dc.KW_ONLY
 
-    repo_subtrees: ta.Sequence[str]
+    repo_subtrees: ta.Optional[ta.Sequence[str]] = None
 
     branch: ta.Optional[str] = None
     rev: ta.Optional[str] = None
@@ -61,7 +61,7 @@ class GitSubtreeCloner:
                 'sparse-checkout',
                 'set',
                 '--no-cone',
-                *self.repo_subtrees,
+                *(self.repo_subtrees or []),
             ),
             cwd=rd,
         )
@@ -84,7 +84,7 @@ def git_clone_subtree(
         repo_dir: str,
         branch: ta.Optional[str] = None,
         rev: ta.Optional[str] = None,
-        repo_subtrees: ta.Sequence[str],
+        repo_subtrees: ta.Optional[ta.Sequence[str]] = None,
 ) -> None:
     for cmd in GitSubtreeCloner(
         base_dir=base_dir,

omdev-0.0.0.dev196/omdev/tagstrings.py

@@ -0,0 +1,206 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import dataclasses as dc
+import typing as ta
+
+from omlish.lite.check import check
+
+
+HierarchyTagStringValue = ta.Tuple[str, ...]  # ta.TypeAlias
+TagStringValue = ta.Union[bool, str, HierarchyTagStringValue]  # ta.TypeAlias
+TagStringValueT = ta.TypeVar('TagStringValueT', bound=TagStringValue)
+
+
+##
+
+
+TAG_STRING_VALUE_TYPES: ta.Tuple = (
+    bool,
+    str,
+    HierarchyTagStringValue,
+)
+
+
+TAG_STRING_BOOL_STR_MAP: ta.Mapping[str, bool] = {'true': True, 'false': False}
+
+
+def check_tag_string_string(s: str) -> str:
+    check.non_empty_str(s)
+    check.equal(s.lower().strip(), s)
+    check.not_in(':', s)
+    return s
+
+
+def build_hierarchy_tag_string_values(m: ta.Mapping[str, ta.Any]) -> ta.FrozenSet[HierarchyTagStringValue]:
+    def rec(c):
+        if isinstance(c, str):
+            yield (c,)
+        elif isinstance(c, ta.Mapping):
+            for k, v in c.items():
+                yield (k,)
+                for n in rec(v):
+                    yield (k, *n)
+        else:
+            raise TypeError(c)
+
+    return frozenset(rec(m))
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TagString(ta.Generic[TagStringValueT]):
+    name: str
+    type: ta.Type[TagStringValueT]
+
+    valid_values: ta.Optional[ta.FrozenSet[TagStringValueT]] = None
+    set: bool = False
+
+    def __post_init__(self) -> None:
+        check_tag_string_string(self.name)
+
+        check.in_(self.type, TAG_STRING_VALUE_TYPES)
+
+        if self.valid_values is not None:
+            check.isinstance(self.valid_values, frozenset)
+
+            v: ta.Any
+            if self.type is bool:
+                for v in self.valid_values:
+                    check.isinstance(v, bool)
+
+            elif self.type is str:
+                for v in self.valid_values:
+                    check_tag_string_string(v)
+
+            elif self.type is HierarchyTagStringValue:
+                for v in self.valid_values:
+                    check.isinstance(v, tuple)
+                    for c in v:
+                        check_tag_string_string(c)
+                    for i in range(1, len(v)):
+                        p = v[:-i]
+                        check.in_(p, self.valid_values)
+
+            else:
+                raise TypeError(self.type)
+
+    #
+
+    @classmethod
+    def new_bool(
+            cls,
+            name: str,
+            valid_values: ta.Optional[ta.Iterable[bool]] = None,
+            **kwargs: ta.Any,
+    ) -> 'TagString':
+        return cls(
+            name=name,
+            type=bool,  # type: ignore
+            valid_values=frozenset(valid_values) if valid_values is not None else None,  # type: ignore
+            **kwargs,
+        )
+
+    @classmethod
+    def new_str(
+            cls,
+            name: str,
+            valid_values: ta.Optional[ta.Iterable[str]] = None,
+            **kwargs: ta.Any,
+    ) -> 'TagString':
+        return cls(
+            name=name,
+            type=str,  # type: ignore
+            valid_values=frozenset(check.not_isinstance(valid_values, str)) if valid_values is not None else None,  # type: ignore  # noqa
+            **kwargs,
+        )
+
+    @classmethod
+    def new_hierarchy(
+            cls,
+            name: str,
+            valid_values: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+            **kwargs: ta.Any,
+    ) -> 'TagString':
+        return cls(
+            name=name,
+            type=HierarchyTagStringValue,  # type: ignore
+            valid_values=build_hierarchy_tag_string_values(valid_values) if valid_values is not None else None,  # type: ignore  # noqa
+            **kwargs,
+        )
+
+
+@dc.dataclass(frozen=True)
+class TagStringSet:
+    dct: ta.Mapping[str, ta.FrozenSet[TagStringValue]]
+
+
+##
+
+
+class TagStringCatalog:
+    def __init__(self, tags: ta.Iterable[TagString]) -> None:
+        super().__init__()
+
+        dct: ta.Dict[str, TagString] = {}
+        for t in tags:
+            check.not_in(t.name, dct)
+            dct[t.name] = t
+        self._by_name = dct
+
+    class Parsed(ta.NamedTuple):
+        tag: TagString
+        values: ta.FrozenSet[TagStringValue]
+
+    def parse_one(self, s: str) -> Parsed:
+        name, *rest = check.non_empty_str(s).split(':')
+
+        tag = self._by_name[name]
+
+        #
+
+        v: TagStringValue
+        if tag.type is bool:
+            bs = check.single(rest)
+            v = TAG_STRING_BOOL_STR_MAP[bs]
+
+        elif tag.type is str:
+            v = check.single(rest)
+
+        elif tag.type is HierarchyTagStringValue:
+            v = tuple(rest)
+
+        else:
+            raise TypeError(tag.type)
+
+        #
+
+        if tag.valid_values is not None:
+            check.in_(v, tag.valid_values)
+
+        #
+
+        vs: ta.FrozenSet[TagStringValue]
+        if tag.type is HierarchyTagStringValue:
+            vt = check.isinstance(v, tuple)
+            vs = frozenset(vt[:i + 1] for i in range(len(vt)))
+        else:
+            vs = frozenset([v])
+
+        #
+
+        return TagStringCatalog.Parsed(tag, vs)
+
+    def parse_set(self, *strs: str) -> TagStringSet:
+        dct: ta.Dict[str, ta.Set[TagStringValue]] = {}
+
+        for s in strs:
+            p = self.parse_one(s)
+
+            if not p.tag.set:
+                check.not_in(p.tag.name, dct)
+
+            dct.setdefault(p.tag.name, set()).update(p.values)
+
+        return TagStringSet({k: frozenset(v) for k, v in dct.items()})

{omdev-0.0.0.dev194 → omdev-0.0.0.dev196}/omdev/tools/cloc.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - handle test code separately
+  - tags again lol - language:, test:, whitespace:, comment:,
+"""
 import dataclasses as dc
 import os
 import re

{omdev-0.0.0.dev194 → omdev-0.0.0.dev196/omdev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omdev
-Version: 0.0.0.dev194
+Version: 0.0.0.dev196
 Summary: omdev
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev194
+Requires-Dist: omlish==0.0.0.dev196
 Provides-Extra: all
 Requires-Dist: black~=24.10; extra == "all"
 Requires-Dist: pycparser~=2.22; extra == "all"

{omdev-0.0.0.dev194 → omdev-0.0.0.dev196}/omdev.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ omdev/imgur.py
 omdev/pip.py
 omdev/revisions.py
 omdev/secrets.py
+omdev/tagstrings.py
 omdev/tokens.py
 omdev/wheelfile.py
 omdev.egg-info/PKG-INFO

{omdev-0.0.0.dev194 → omdev-0.0.0.dev196}/omdev.egg-info/requires.txt

@@ -1,4 +1,4 @@
-omlish==0.0.0.dev194
+omlish==0.0.0.dev196
 
 [all]
 black~=24.10

{omdev-0.0.0.dev194 → omdev-0.0.0.dev196}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev194'
+version = '0.0.0.dev196'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',
@@ -22,7 +22,7 @@ classifiers = [
 ]
 description = 'omdev'
 dependencies = [
-    'omlish == 0.0.0.dev194',
+    'omlish == 0.0.0.dev196',
 ]
 
 [project.optional-dependencies]