omlish 0.0.0.dev1__py3-none-any.whl

omlish/lang/resolving.py

@@ -0,0 +1,50 @@
+import importlib
+import string
+import typing as ta
+
+
+class ResolvableClassNameError(NameError):
+    pass
+
+
+def get_cls_fqcn(cls: type, *, nocheck: bool = False) -> str:
+    if not isinstance(cls, type):
+        raise TypeError(cls)
+    mn = cls.__module__
+    if set(mn) - set(string.ascii_lowercase + string.digits + '_.'):
+        raise ResolvableClassNameError(cls)
+    qn = cls.__qualname__
+    if not all(qp[0].isupper() for qp in qn.split('.')) or (set(qn) - set(string.ascii_letters + string.digits + '.')):
+        raise ResolvableClassNameError(cls)
+    fqcn = '.'.join([cls.__module__, cls.__qualname__])
+    if not nocheck:
+        if get_fqcn_cls(fqcn, nocheck=True) is not cls:
+            raise ResolvableClassNameError(cls, fqcn)
+    return fqcn
+
+
+def get_fqcn_cls(fqcn: str, *, nocheck: bool = False) -> type:
+    if not isinstance(fqcn, str) or not fqcn:
+        raise TypeError(fqcn)
+    parts = fqcn.split('.')
+    pos = next(i for i, p in enumerate(parts) if p[0].isupper())
+    mps, qps = parts[:pos], parts[pos:]
+    mod = importlib.import_module('.'.join(mps))
+    o: ta.Any = mod
+    for qp in qps:
+        o = getattr(o, qp)
+        if not isinstance(o, type):
+            raise TypeError(o)
+    cls = o
+    if not isinstance(cls, type):
+        raise TypeError(cls)
+    if not nocheck:
+        if not get_cls_fqcn(cls, nocheck=True) == fqcn:
+            raise ResolvableClassNameError(cls, fqcn)
+    return o
+
+
+class Resolvable:
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        get_cls_fqcn(cls, nocheck=True)

omlish/lang/strings.py

@@ -0,0 +1,128 @@
+import typing as ta
+import unicodedata
+
+
+##
+
+
+def prefix_lines(s: str, p: str) -> str:
+    return '\n'.join([p + l for l in s.split('\n')])
+
+
+def indent_lines(s: str, num: int) -> str:
+    return prefix_lines(s, ' ' * num)
+
+
+##
+
+
+def camel_case(name: str) -> str:
+    return ''.join(map(str.capitalize, name.split('_')))  # noqa
+
+
+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
+        name[2:3] != '_' and
+        name[-3:-2] != '_' and
+        len(name) > 4
+    )
+
+
+def is_sunder(name: str) -> bool:
+    return (
+        name[0] == name[-1] == '_' and
+        name[1:2] != '_' and
+        name[-2:-1] != '_' and
+        len(name) > 2
+    )
+
+
+##
+
+
+class _CharSpec(ta.NamedTuple):
+    cats: ta.AbstractSet[str]
+    chars: ta.AbstractSet[str]
+
+
+_IDENT_START_CHAR_SPEC = _CharSpec(
+    {
+        'Ll',
+        'Lm',
+        'Lo',
+        'Lt',
+        'Lu',
+        'Nl',
+    },
+    {
+        '_',
+        '\u2118',
+        '\u212E',
+        '\u309B',
+        '\u309C',
+    },
+)
+
+
+_IDENT_CONT_CHAR_SPEC = _CharSpec(
+    {
+        'Ll',
+        'Lm',
+        'Lo',
+        'Lt',
+        'Lu',
+        'Mc',
+        'Mn',
+        'Nd',
+        'Nl',
+        'Pc',
+    },
+    {
+        '_',
+        '\u00B7',
+        '\u0387',
+        '\u1369',
+        '\u136A',
+        '\u136B',
+        '\u136C',
+        '\u136D',
+        '\u136E',
+        '\u136F',
+        '\u1370',
+        '\u1371',
+        '\u19DA',
+        '\u2118',
+        '\u212E',
+        '\u309B',
+        '\u309C',
+    },
+)
+
+
+def _is_char_in_spec(spec: _CharSpec, c: str) -> bool:
+    if len(c) != 1:
+        raise ValueError(c)
+    return (
+        unicodedata.category(c) in spec.cats or
+        c in spec.chars or
+        unicodedata.category(unicodedata.normalize('NFKC', c)) in spec.cats or
+        unicodedata.normalize('NFKC', c) in spec.chars
+    )
+
+
+def is_ident_start(c: str) -> bool:
+    return _is_char_in_spec(_IDENT_START_CHAR_SPEC, c)
+
+
+def is_ident_cont(c: str) -> bool:
+    return _is_char_in_spec(_IDENT_CONT_CHAR_SPEC, c)
+
+
+def is_ident(name: str) -> bool:
+    return is_ident_start(name[0]) and all(is_ident_cont(c) for c in name[1:])

omlish/lang/typing.py

@@ -0,0 +1,92 @@
+"""
+TODO:
+ - typed_lambda is really kinda just 'annotate'
+ - TypedLambda / TypedPartial classes, picklable, reprs
+  - probably need to gen types per inst
+"""
+import functools
+import inspect
+import typing as ta
+
+
+Ty = ta.TypeVar('Ty', bound=type)
+
+
+BytesLike: ta.TypeAlias = ta.Union[bytes, bytearray]
+
+
+##
+
+
+def protocol_check(proto: type) -> ta.Callable[[Ty], Ty]:
+    def inner(cls):
+        if not issubclass(cls, proto):
+            raise TypeError(cls)
+        return cls
+    return inner
+
+
+##
+
+
+_MISSING = object()
+
+
+def _update_wrapper_no_anns(wrapper, wrapped):
+    functools.update_wrapper(wrapper, wrapped, assigned=list(set(functools.WRAPPER_ASSIGNMENTS) - {'__annotations__'}))
+    return wrapper
+
+
+def typed_lambda(ret=_MISSING, **kw):
+    def inner(fn):
+        ns = {}
+        ns['__fn'] = fn
+        proto = ['def __lam(']
+        call = ['return __fn(']
+        pkw = {k: v for k, v in kw.items()}
+        for i, (n, t) in enumerate(pkw.items()):
+            if i:
+                call.append(', ')
+            else:
+                proto.append('*')
+            ns['__ann_' + n] = t
+            proto.append(f', {n}: __ann_{n}')
+            call.append(f'{n}={n}')
+        proto.append(')')
+        if ret is not _MISSING:
+            ns['__ann_return'] = ret
+            proto.append(f' -> __ann_return')
+        proto.append(':')
+        call.append(')')
+        src = f'{"".join(proto)} {"".join(call)}'
+        exec(src, ns)
+        lam = _update_wrapper_no_anns(ns['__lam'], fn)
+        lam.__signature__ = inspect.signature(lam, follow_wrapped=False)
+        return lam
+    for k in kw:
+        if k.startswith('__'):
+            raise NameError(k)
+    return inner
+
+
+def typed_partial(obj, **kw):
+    for k in kw:
+        if k.startswith('__'):
+            raise NameError(k)
+    sig = inspect.signature(obj)
+    inner = _update_wrapper_no_anns(lambda **lkw: obj(**lkw, **kw), obj)
+    ret = (
+        obj if isinstance(obj, type) else
+        sig.return_annotation if sig.return_annotation is not inspect.Signature.empty else
+        _MISSING
+    )
+    lam = typed_lambda(
+        ret,
+        **{
+            n: p.annotation
+            for n, p in sig.parameters.items()
+            if n not in kw
+            and p.annotation is not inspect.Signature.empty
+        }
+    )(inner)
+    return _update_wrapper_no_anns(lam, obj)