omlish 0.0.0.dev302__tar.gz → 0.0.0.dev303__tar.gz

{omlish-0.0.0.dev302/omlish.egg-info → omlish-0.0.0.dev303}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev302
+Version: 0.0.0.dev303
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev302 → omlish-0.0.0.dev303}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev302'
-__revision__ = '0b4f820252a0f7a3e020da512ead1e112d150cd2'
+__version__ = '0.0.0.dev303'
+__revision__ = '8c675f0f9a5c459eddf54867184cd1da05cff6ac'
 
 
 #

{omlish-0.0.0.dev302 → omlish-0.0.0.dev303}/omlish/bootstrap/harness.py

@@ -35,7 +35,7 @@ from .base import SimpleBootstrap
 
 
 BOOTSTRAP_TYPES_BY_NAME: ta.Mapping[str, ta.Type[Bootstrap]] = {  # noqa
-    lang.snake_case(cls.__name__[:-len('Bootstrap')]): cls
+    lang.snake_case(*lang.split_string_casing(cls.__name__[:-len('Bootstrap')])): cls
     for cls in lang.deep_subclasses(Bootstrap, concrete_only=True)
 }
 

{omlish-0.0.0.dev302 → omlish-0.0.0.dev303}/omlish/lang/__init__.py

@@ -23,6 +23,33 @@ from .cached.property import (  # noqa
     cached_property,
 )
 
+from .casing import (  # noqa
+    StringCasingError,
+    ImproperStringCasingError,
+    UnknownStringCasingError,
+    AmbiguousStringCasingError,
+
+    StringCasing,
+    CamelCase,
+    LowCamelCase,
+    SnakeCase,
+    UpSnakeCase,
+
+    STRING_CASINGS,
+    CAMEL_CASE,
+    LOW_CAMEL_CASE,
+    SNAKE_CASE,
+    UP_SNAKE_CASE,
+
+    camel_case,
+    low_camel_case,
+    snake_case,
+    up_snake_case,
+
+    get_string_casing,
+    split_string_casing,
+)
+
 from .classes.abstract import (  # noqa
     Abstract,
     AbstractTypeError,
@@ -260,7 +287,6 @@ from .strings import (  # noqa
     BOOL_STRINGS,
     BOOL_TRUE_STRINGS,
     STRING_BOOL_VALUES,
-    camel_case,
     find_any,
     indent_lines,
     is_dunder,
@@ -272,7 +298,6 @@ from .strings import (  # noqa
     prefix_lines,
     replace_many,
     rfind_any,
-    snake_case,
     strip_prefix,
     strip_suffix,
 )

omlish-0.0.0.dev303/omlish/lang/casing.py

@@ -0,0 +1,192 @@
+import abc
+import re
+import typing as ta
+
+
+##
+
+
+class StringCasingError(Exception):
+    pass
+
+
+class ImproperStringCasingError(StringCasingError):
+    pass
+
+
+class UnknownStringCasingError(StringCasingError):
+    pass
+
+
+class AmbiguousStringCasingError(StringCasingError):
+    pass
+
+
+def _check_all_lowercase(*ps: str) -> None:
+    for p in ps:
+        if p.lower() != p:
+            raise ImproperStringCasingError(p)
+
+
+##
+
+
+class StringCasing(abc.ABC):
+    @abc.abstractmethod
+    def match(self, s: str) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def split(self, s: str) -> list[str]:
+        """Returns lowercase."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def join(self, *parts: str) -> str:
+        """Expects lowercase."""
+
+        raise NotImplementedError
+
+
+#
+
+
+class CamelCase(StringCasing):
+    """FooBarBaz"""
+
+    _PAT: ta.ClassVar[re.Pattern] = re.compile(r'[A-Z][a-z0-9]*(?:[A-Z][a-z0-9]*)*')
+    _SPLIT_PAT: ta.ClassVar[re.Pattern] = re.compile(r'[A-Z][a-z0-9]*')
+
+    def match(self, s: str) -> bool:
+        return bool(self._PAT.fullmatch(s))
+
+    def split(self, s: str) -> list[str]:
+        if not self.match(s):
+            raise ImproperStringCasingError(f'Not valid CamelCase: {s!r}')
+        return [m.group(0).lower() for m in self._SPLIT_PAT.finditer(s)]
+
+    def join(self, *parts: str) -> str:
+        _check_all_lowercase(*parts)
+        return ''.join(p.capitalize() for p in parts)
+
+
+#
+
+
+class LowCamelCase(StringCasing):
+    """fooBarBaz"""
+
+    _MATCH_PAT: ta.ClassVar[re.Pattern] = re.compile(r'[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*')
+    _SPLIT_PAT: ta.ClassVar[re.Pattern] = re.compile(r'^[a-z0-9]+')
+    _UPPER_PAT: ta.ClassVar[re.Pattern] = re.compile(r'[A-Z][a-z0-9]*')
+
+    def match(self, s: str) -> bool:
+        return bool(self._MATCH_PAT.fullmatch(s))
+
+    def split(self, s: str) -> list[str]:
+        if not self.match(s):
+            raise ImproperStringCasingError(f'Not valid lowCamelCase: {s!r}')
+        parts: list[str] = []
+        m0 = self._SPLIT_PAT.match(s)
+        if m0:
+            parts.append(m0.group(0))
+            start = m0.end()
+        else:
+            start = 0
+        for m in self._UPPER_PAT.finditer(s, pos=start):
+            parts.append(m.group(0))
+        return [p.lower() for p in parts]
+
+    def join(self, *parts: str) -> str:
+        _check_all_lowercase(*parts)
+        if not parts:
+            return ''
+        first, *rest = parts
+        return first.lower() + ''.join(p.capitalize() for p in rest)
+
+
+#
+
+
+class SnakeCase(StringCasing):
+    """foo_bar_baz"""
+
+    _PAT: ta.ClassVar[re.Pattern] = re.compile(r'[a-z0-9]+(?:_[a-z0-9]+)*')
+
+    def match(self, s: str) -> bool:
+        return bool(self._PAT.fullmatch(s))
+
+    def split(self, s: str) -> list[str]:
+        if not self.match(s):
+            raise ImproperStringCasingError(f'Not valid snake_case: {s!r}')
+        return s.split('_')
+
+    def join(self, *parts: str) -> str:
+        _check_all_lowercase(*parts)
+        return '_'.join(p.lower() for p in parts)
+
+
+#
+
+
+class UpSnakeCase(StringCasing):
+    """FOO_BAR_BAZ"""
+
+    _PAT: ta.ClassVar[re.Pattern] = re.compile(r'[A-Z0-9]+(?:_[A-Z0-9]+)*')
+
+    def match(self, s: str) -> bool:
+        return bool(self._PAT.fullmatch(s))
+
+    def split(self, s: str) -> list[str]:
+        if not self.match(s):
+            raise ImproperStringCasingError(f'Not valid UPPER_SNAKE_CASE: {s!r}')
+        return [part.lower() for part in s.split('_')]
+
+    def join(self, *parts: str) -> str:
+        _check_all_lowercase(*parts)
+        return '_'.join(p.upper() for p in parts)
+
+
+##
+
+
+STRING_CASINGS = [
+    (CAMEL_CASE := CamelCase()),
+    (LOW_CAMEL_CASE := LowCamelCase()),
+    (SNAKE_CASE := SnakeCase()),
+    (UP_SNAKE_CASE := UpSnakeCase()),
+]
+
+
+camel_case = CAMEL_CASE.join
+low_camel_case = LOW_CAMEL_CASE.join
+snake_case = SNAKE_CASE.join
+up_snake_case = UP_SNAKE_CASE.join
+
+
+##
+
+
+def get_string_casing(s: str, casings: ta.Iterable[StringCasing] | None = None) -> StringCasing:
+    if casings is None:
+        casings = STRING_CASINGS
+    cs = [c for c in casings if c.match(s)]
+    if not cs:
+        raise UnknownStringCasingError
+    if len(cs) != 1:
+        raise AmbiguousStringCasingError
+    [c] = cs
+    return c
+
+
+def split_string_casing(s: str, casings: ta.Iterable[StringCasing] | None = None) -> list[str]:
+    if casings is None:
+        casings = STRING_CASINGS
+    ts = {tuple(c.split(s)) for c in casings if c.match(s)}
+    if not ts:
+        raise UnknownStringCasingError
+    if len(ts) != 1:
+        raise AmbiguousStringCasingError
+    [t] = ts
+    return list(t)

{omlish-0.0.0.dev302 → omlish-0.0.0.dev303}/omlish/lang/strings.py

@@ -84,23 +84,6 @@ def rfind_any(
 ##
 
 
-def camel_case(name: str, *, lower: bool = False) -> str:
-    if not name:
-        return ''
-    s = ''.join(map(str.capitalize, name.split('_')))  # noqa
-    if lower:
-        s = s[0].lower() + s[1:]
-    return s
-
-
-def snake_case(name: str) -> str:
-    uppers: list[int | None] = [i for i, c in enumerate(name) if c.isupper()]
-    return '_'.join([name[l:r].lower() for l, r in zip([None, *uppers], [*uppers, None])]).strip('_')
-
-
-##
-
-
 def is_dunder(name: str) -> bool:
     return (
         name[:2] == name[-2:] == '__' and

omlish-0.0.0.dev303/omlish/marshal/naming.py

@@ -0,0 +1,38 @@
+"""
+TODO:
+ - Namer: ta.TypeAlias = ta.Callable[[str], str] ?
+  - this interface is ~intentionally~ limited, but custom overrides would be useful
+"""
+import enum
+
+from .. import check
+from .. import lang
+from .base import Option
+
+
+class Naming(Option, enum.Enum):
+    SNAKE = 'snake'
+    CAMEL = 'camel'
+    LOW_CAMEL = 'low_camel'
+
+
+def translate_name(n: str, e: Naming) -> str:
+    check.non_empty_str(n)
+    check.not_equal(set(n), {'_'})
+
+    n1 = n.lstrip('_')
+    pfx = '_' * (len(n) - len(n1))
+    n2 = n1.rstrip('_')
+    sfx = '_' * (len(n1) - len(n2))
+    ps = lang.split_string_casing(n2)
+
+    if e is Naming.SNAKE:
+        r = lang.snake_case(*ps)
+    elif e is Naming.CAMEL:
+        r = lang.camel_case(*ps)
+    elif e is Naming.LOW_CAMEL:
+        r = lang.low_camel_case(*ps)
+    else:
+        raise ValueError(e)
+
+    return pfx + r + sfx

{omlish-0.0.0.dev302 → omlish-0.0.0.dev303}/omlish/specs/jmespath/visitor.py

@@ -104,7 +104,7 @@ def _is_actual_number(x: ta.Any) -> bool:
 
 
 def node_type(n: Node) -> str:
-    return lang.snake_case(type(n).__name__)
+    return lang.snake_case(*lang.split_string_casing(type(n).__name__))
 
 
 ##

{omlish-0.0.0.dev302 → omlish-0.0.0.dev303/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev302
+Version: 0.0.0.dev303
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev302 → omlish-0.0.0.dev303}/omlish.egg-info/SOURCES.txt

@@ -476,6 +476,7 @@ omlish/iterators/tools.py
 omlish/iterators/unique.py
 omlish/lang/__init__.py
 omlish/lang/attrs.py
+omlish/lang/casing.py
 omlish/lang/clsdct.py
 omlish/lang/collections.py
 omlish/lang/comparison.py

{omlish-0.0.0.dev302 → omlish-0.0.0.dev303}/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.dev302'
+version = '0.0.0.dev303'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev302/omlish/marshal/naming.py

@@ -1,26 +0,0 @@
-"""
-TODO:
- - Namer: ta.TypeAlias = ta.Callable[[str], str] ?
-  - this interface is ~intentionally~ limited, but custom overrides would be useful
-"""
-import enum
-
-from .. import lang
-from .base import Option
-
-
-class Naming(Option, enum.Enum):
-    SNAKE = 'snake'
-    CAMEL = 'camel'
-    LOW_CAMEL = 'low_camel'
-
-
-def translate_name(n: str, e: Naming) -> str:
-    if e is Naming.SNAKE:
-        return lang.snake_case(n)
-    if e is Naming.CAMEL:
-        return lang.camel_case(n)
-    if e is Naming.LOW_CAMEL:
-        r = lang.camel_case(n)
-        return (r[0].lower() + r[1:]) if r else r
-    raise ValueError(e)