omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev6__py3-none-any.whl

omlish/reflect.py

@@ -1,6 +1,6 @@
 """
 TODO:
- - callables..
+ - visitor / transformer
  - uniform collection isinstance - items() for mappings, iter() for other
  - also check instance type in isinstance not just items lol
  - ta.Generic in mro causing trouble - omit? no longer 1:1
@@ -8,6 +8,7 @@ TODO:
   - cache __hash__ in Generic/Union
 """
 import collections.abc
+import dataclasses as dc
 import types
 import typing as ta
 
@@ -27,9 +28,10 @@ _NONE_TYPE_FROZENSET: frozenset['Type'] = frozenset([_NoneType])
 
 
 _GenericAlias = ta._GenericAlias  # type: ignore  # noqa
-# _CallableGenericAlias = ta._CallableGenericAlias  # type: ignore  # noqa
+_CallableGenericAlias = ta._CallableGenericAlias  # type: ignore  # noqa
 _SpecialGenericAlias = ta._SpecialGenericAlias  # type: ignore  # noqa
 _UnionGenericAlias = ta._UnionGenericAlias   # type: ignore  # noqa
+_AnnotatedAlias = ta._AnnotatedAlias  # type: ignore  # noqa
 
 
 ##
@@ -57,9 +59,11 @@ _KNOWN_SPECIALS_BY_NAME = {s.name: s for s in _KNOWN_SPECIALS}
 _KNOWN_SPECIALS_BY_ALIAS = {s.alias: s for s in _KNOWN_SPECIALS}
 _KNOWN_SPECIALS_BY_ORIGIN = {s.origin: s for s in _KNOWN_SPECIALS}
 
+_MAX_KNOWN_SPECIAL_TYPE_VARS = 16
+
 _KNOWN_SPECIAL_TYPE_VARS = tuple(
     ta.TypeVar(f'_{i}')  # noqa
-    for i in range(max(s.nparams for s in _KNOWN_SPECIALS) + 1)
+    for i in range(_MAX_KNOWN_SPECIAL_TYPE_VARS)
 )
 
 
@@ -76,28 +80,40 @@ def get_params(obj: ta.Any) -> tuple[ta.TypeVar, ...]:
 
     oty = type(obj)
 
-    if oty is _GenericAlias or oty is ta.GenericAlias:  # type: ignore  # noqa
+    if (
+            oty is _GenericAlias or
+            oty is ta.GenericAlias  # type: ignore  # noqa
+    ):
         return obj.__dict__.get('__parameters__', ())  # noqa
 
+    if oty is _CallableGenericAlias:
+        raise NotImplementedError('get_params not yet implemented for typing.Callable')
+
     raise TypeError(obj)
 
 
 def is_union_type(cls: ta.Any) -> bool:
     if hasattr(ta, 'UnionType'):
         return ta.get_origin(cls) in {ta.Union, getattr(ta, 'UnionType')}
+
     else:
         return ta.get_origin(cls) in {ta.Union}
 
 
+def get_orig_class(obj: ta.Any) -> ta.Any:
+    return obj.__orig_class__  # noqa
+
+
 ##
 
 
 Type = ta.Union[
     type,
     ta.TypeVar,
-    'NewType',
     'Union',
     'Generic',
+    'NewType',
+    'Annotated',
 ]
 
 
@@ -117,19 +133,26 @@ class Union(ta.NamedTuple):
         return Union(rem)
 
 
-class Generic(ta.NamedTuple):
+@dc.dataclass(frozen=True)
+class Generic:
     cls: type
-    args: tuple[Type, ...]             # map[int, V] = (int, V) | map[T, T] = (T, T)
-    params: tuple[ta.TypeVar, ...]     # map[int, V] = (_0, _1) | map[T, T] = (_0, _1)
-    # params2: tuple[ta.TypeVar, ...]  # map[int, V] = (V,)     | map[T, T] = (T,)
-    obj: ta.Any
+    args: tuple[Type, ...]                                                # map[int, V] = (int, V) | map[T, T] = (T, T)
+
+    params: tuple[ta.TypeVar, ...] = dc.field(compare=False, repr=False)  # map[int, V] = (_0, _1) | map[T, T] = (_0, _1)  # noqa
+    # params2: tuple[ta.TypeVar, ...]                                     # map[int, V] = (V,)     | map[T, T] = (T,)
+
+    obj: ta.Any = dc.field(compare=False, repr=False)
 
-    def __repr__(self) -> str:
+    # def __post_init__(self) -> None:
+    #     if not isinstance(self.cls, type):
+    #         raise TypeError(self.cls)
+
+    def full_eq(self, other: 'Generic') -> bool:
         return (
-            f'{self.__class__.__name__}('
-            f'cls={self.cls.__name__}, '
-            f'args={self.args!r}, '
-            f'params={self.params!r})'
+            self.cls == other.cls and
+            self.args == other.args and
+            self.params == other.params and
+            self.obj == other.obj
         )
 
 
@@ -137,15 +160,50 @@ class NewType(ta.NamedTuple):
     obj: ta.Any
 
 
+@dc.dataclass(frozen=True)
+class Annotated:
+    ty: Type
+    md: ta.Sequence[ta.Any]
+
+    obj: ta.Any = dc.field(compare=False, repr=False)
+
+
 TYPES: tuple[type, ...] = (
     type,
     ta.TypeVar,
     Union,
     Generic,
     NewType,
+    Annotated,
 )
 
 
+##
+
+
+def is_type(obj: ta.Any) -> bool:
+    if isinstance(obj, (Union, Generic, ta.TypeVar, NewType)):  # noqa
+        return True
+
+    oty = type(obj)
+
+    return (
+        oty is _UnionGenericAlias or oty is types.UnionType or  # noqa
+
+        isinstance(obj, ta.NewType) or  # noqa
+
+        (
+            oty is _GenericAlias or
+            oty is ta.GenericAlias or  # type: ignore  # noqa
+            oty is _CallableGenericAlias
+        ) or
+
+        isinstance(obj, type) or
+
+        isinstance(obj, _SpecialGenericAlias)
+    )
+
+
 def type_(obj: ta.Any) -> Type:
     if isinstance(obj, (Union, Generic, ta.TypeVar, NewType)):  # noqa
         return obj
@@ -156,15 +214,22 @@ def type_(obj: ta.Any) -> Type:
         return Union(frozenset(type_(a) for a in ta.get_args(obj)))
 
     if isinstance(obj, ta.NewType):  # noqa
-        return NewType(oty)
+        return NewType(obj)
 
     if (
             oty is _GenericAlias or
-            oty is ta.GenericAlias  # type: ignore  # noqa
+            oty is ta.GenericAlias or  # type: ignore  # noqa
+            oty is _CallableGenericAlias
     ):
         origin = ta.get_origin(obj)
         args = ta.get_args(obj)
-        if origin is ta.Generic:
+        if oty is _CallableGenericAlias:
+            p, r = args
+            if p is Ellipsis or isinstance(p, ta.ParamSpec):
+                raise TypeError(f'Callable argument not yet supported for {obj=}')
+            args = (*p, r)
+            params = _KNOWN_SPECIAL_TYPE_VARS[:len(args)]
+        elif origin is ta.Generic:
             params = args
         else:
             params = get_params(origin)
@@ -198,15 +263,52 @@ def type_(obj: ta.Any) -> Type:
                 obj,
             )
 
+    if isinstance(obj, _AnnotatedAlias):
+        o = ta.get_args(obj)[0]
+        return Annotated(type_(o), md=obj.__metadata__, obj=obj)
+
     raise TypeError(obj)
 
 
 ##
 
 
+def strip_objs(ty: Type) -> Type:
+    if isinstance(ty, (type, ta.TypeVar, NewType)):
+        return ty
+
+    if isinstance(ty, Union):
+        return Union(frozenset(map(strip_objs, ty.args)))
+
+    if isinstance(ty, Generic):
+        return Generic(ty.cls, tuple(map(strip_objs, ty.args)), ty.params, None)
+
+    if isinstance(ty, Annotated):
+        return Annotated(strip_objs(ty.ty), ty.md, None)
+
+    raise TypeError(ty)
+
+
+def strip_annotations(ty: Type) -> Type:
+    if isinstance(ty, (type, ta.TypeVar, NewType)):
+        return ty
+
+    if isinstance(ty, Union):
+        return Union(frozenset(map(strip_annotations, ty.args)))
+
+    if isinstance(ty, Generic):
+        return Generic(ty.cls, tuple(map(strip_annotations, ty.args)), ty.params, ty.obj)
+
+    if isinstance(ty, Annotated):
+        return strip_annotations(ty.ty)
+
+    raise TypeError(ty)
+
+
 def types_equivalent(l: Type, r: Type) -> bool:
     if isinstance(l, Generic) and isinstance(r, Generic):
         return l.cls == r.cls and l.args == r.args
+
     return l == r
 
 
@@ -217,28 +319,36 @@ def get_underlying(nt: NewType) -> Type:
 def get_concrete_type(ty: Type) -> type | None:
     if isinstance(ty, type):
         return ty
+
     if isinstance(ty, Generic):
         return ty.cls
+
     if isinstance(ty, NewType):
         return get_concrete_type(get_underlying(ty))
+
     if isinstance(ty, (Union, ta.TypeVar)):
         return None
+
     raise TypeError(ty)
 
 
 def get_type_var_replacements(ty: Type) -> ta.Mapping[ta.TypeVar, Type]:
     if isinstance(ty, Generic):
         return dict(zip(ty.params, ty.args))
+
     return {}
 
 
 def to_annotation(ty: Type) -> ta.Any:
     if isinstance(ty, Generic):
         return ty.obj if ty.obj is not None else ty.cls
+
     if isinstance(ty, Union):
         return ta.Union[*tuple(to_annotation(e) for e in ty.args)]
+
     if isinstance(ty, (type, ta.TypeVar, NewType)):
         return ty
+
     raise TypeError(ty)
 
 
@@ -251,8 +361,10 @@ def replace_type_vars(
     def rec(cur):
         if isinstance(cur, type):
             return cur
+
         if isinstance(cur, NewType):
             return cur
+
         if isinstance(cur, Generic):
             args = tuple(rec(a) for a in cur.args)
             if update_aliases:
@@ -266,11 +378,14 @@ def replace_type_vars(
                         obj = cur.obj[*nargs]
             else:
                 obj = None
-            return cur._replace(args=args, obj=obj)
+            return dc.replace(cur, args=args, obj=obj)
+
         if isinstance(cur, Union):
             return Union(frozenset(rec(e) for e in cur.args))
+
         if isinstance(cur, ta.TypeVar):
             return rpl[cur]
+
         raise TypeError(cur)
 
     return rec(ty)

omlish/secrets/__init__.py

@@ -0,0 +1,7 @@
+from .secrets import (  # noqa
+    EMPTY_SECRETS,
+    EmptySecrets,
+    Secret,
+    Secrets,
+    SimpleSecrets,
+)

omlish/secrets/marshal.py

@@ -0,0 +1,41 @@
+import collections.abc
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import marshal as msh
+from .secrets import Secret
+
+
+class StrOrSecretMarshaler(msh.Marshaler):
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        if isinstance(o, str):
+            return o
+        elif isinstance(o, Secret):
+            return {'secret': o.key}
+        else:
+            raise TypeError(o)
+
+
+class StrOrSecretUnmarshaler(msh.Unmarshaler):
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        if isinstance(v, str):
+            return v
+        elif isinstance(v, collections.abc.Mapping):
+            [(mk, mv)] = v.items()
+            if mk != 'secret':
+                raise TypeError(v)
+            return Secret(check.isinstance(mv, str))
+        else:
+            raise TypeError(v)
+
+
+@dc.field_modifier
+def marshal_secret_field(f: dc.Field) -> dc.Field:
+    return dc.update_field_metadata(f, {
+        msh.FieldMetadata: dc.replace(
+            f.metadata.get(msh.FieldMetadata, msh.FieldMetadata()),
+            marshaler=StrOrSecretMarshaler(),
+            unmarshaler=StrOrSecretUnmarshaler(),
+        ),
+    })

omlish/secrets/passwords.py

@@ -0,0 +1,120 @@
+"""
+~> https://github.com/pallets/werkzeug/blob/7a76170c473c26685bdfa2774d083ba2386fc60f/src/werkzeug/security.py
+"""
+# Copyright 2007 Pallets
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+# 1.  Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+#     disclaimer.
+#
+# 2.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#     following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+# 3.  Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
+#     products derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import hashlib
+import hmac
+import secrets
+
+
+SALT_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+DEFAULT_PBKDF2_ITERATIONS = 600000
+
+
+def gen_salt(length: int) -> str:
+    if length <= 0:
+        raise ValueError('Salt length must be at least 1.')
+
+    return ''.join(secrets.choice(SALT_CHARS) for _ in range(length))
+
+
+def _hash_internal(
+        method: str,
+        salt: str,
+        password: str,
+) -> tuple[str, str]:
+    method, *args = method.split(':')
+    salt_bytes = salt.encode()
+    password_bytes = password.encode()
+
+    if method == 'scrypt':
+        if not args:
+            n = 2 ** 15
+            r = 8
+            p = 1
+        else:
+            try:
+                n, r, p = map(int, args)
+            except ValueError:
+                raise ValueError("'scrypt' takes 3 arguments.") from None
+
+        maxmem = 132 * n * r * p  # ideally 128, but some extra seems needed
+
+        return (
+            hashlib.scrypt(
+                password_bytes,
+                salt=salt_bytes,
+                n=n,
+                r=r,
+                p=p,
+                maxmem=maxmem,
+            ).hex(),
+            f'scrypt:{n}:{r}:{p}',
+        )
+
+    elif method == 'pbkdf2':
+        len_args = len(args)
+
+        if len_args == 0:
+            hash_name = 'sha256'
+            iterations = DEFAULT_PBKDF2_ITERATIONS
+        elif len_args == 1:
+            hash_name = args[0]
+            iterations = DEFAULT_PBKDF2_ITERATIONS
+        elif len_args == 2:
+            hash_name = args[0]
+            iterations = int(args[1])
+        else:
+            raise ValueError("'pbkdf2' takes 2 arguments.")
+
+        return (
+            hashlib.pbkdf2_hmac(
+                hash_name,
+                password_bytes,
+                salt_bytes,
+                iterations,
+            ).hex(),
+            f'pbkdf2:{hash_name}:{iterations}',
+        )
+
+    else:
+        raise ValueError(f"Invalid hash method '{method}'.")
+
+
+def generate_password_hash(
+        password: str,
+        method: str = 'scrypt',
+        salt_length: int = 16,
+) -> str:
+    salt = gen_salt(salt_length)
+    h, actual_method = _hash_internal(method, salt, password)
+    return f'{actual_method}${salt}${h}'
+
+
+def check_password_hash(pwhash: str, password: str) -> bool:
+    try:
+        method, salt, hashval = pwhash.split('$', 2)
+    except ValueError:
+        return False
+
+    return hmac.compare_digest(_hash_internal(method, salt, password)[0], hashval)

omlish/secrets/secrets.py

@@ -0,0 +1,47 @@
+import abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Secret:
+    key: str
+
+
+##
+
+
+class Secrets(lang.Abstract):
+    def fix(self, obj: str | Secret) -> str:
+        if isinstance(obj, str):
+            return obj
+        elif isinstance(obj, Secret):
+            return self.get(obj.key)
+        else:
+            raise TypeError(obj)
+
+    @abc.abstractmethod
+    def get(self, key: str) -> str:
+        raise NotImplementedError
+
+
+class EmptySecrets(Secrets):
+    def get(self, key: str) -> str:
+        raise KeyError(key)
+
+
+EMPTY_SECRETS = EmptySecrets()
+
+
+class SimpleSecrets(Secrets):
+    def __init__(self, dct: ta.Mapping[str, str]) -> None:
+        super().__init__()
+        self._dct = dct
+
+    def get(self, key: str) -> str:
+        return self._dct[key]

omlish/{configs → serde}/dotenv.py

@@ -332,6 +332,7 @@ class DotEnv:
         encoding: str | None = None,
         interpolate: bool = True,
         override: bool = True,
+        env: ta.Mapping[str, str] | None = None,
     ) -> None:
         super().__init__()
         self.path: StrPath | None = path
@@ -341,6 +342,7 @@ class DotEnv:
         self.encoding: str | None = encoding
         self.interpolate: bool = interpolate
         self.override: bool = override
+        self.env = env or {}
 
     @contextlib.contextmanager
     def _get_stream(self) -> ta.Iterator[ta.IO[str]]:
@@ -364,7 +366,7 @@ class DotEnv:
         raw_values = self.parse()
 
         if self.interpolate:
-            self._dict = resolve_variables(raw_values, override=self.override)
+            self._dict = resolve_variables(raw_values, override=self.override, env=self.env)
         else:
             self._dict = dict(raw_values)
 
@@ -376,22 +378,7 @@ class DotEnv:
                 if mapping.key is not None:
                     yield mapping.key, mapping.value
 
-    def set_as_environment_variables(self) -> bool:
-        """Load the current dotenv as system environment variable."""
-        if not self.dict():
-            return False
-
-        for k, v in self.dict().items():
-            if k in os.environ and not self.override:
-                continue
-            if v is not None:
-                os.environ[k] = v
-
-        return True
-
     def get(self, key: str) -> str | None:
-        """
-        """
         data = self.dict()
 
         if key in data:
@@ -525,8 +512,9 @@ def unset_key(
 
 
 def resolve_variables(
-    values: ta.Iterable[tuple[str, str | None]],
-    override: bool,
+        values: ta.Iterable[tuple[str, str | None]],
+        override: bool,
+        env: ta.Mapping[str, str],
 ) -> dict[str, str | None]:
     new_values: dict[str, str | None] = {}
 
@@ -535,14 +523,14 @@ def resolve_variables(
             result = None
         else:
             atoms = parse_variables(value)
-            env: dict[str, str | None] = {}
+            aenv: dict[str, str | None] = {}
             if override:
-                env.update(os.environ)
-                env.update(new_values)
+                aenv.update(env)
+                aenv.update(new_values)
             else:
-                env.update(new_values)
-                env.update(os.environ)
-            result = ''.join(atom.resolve(env) for atom in atoms)
+                aenv.update(new_values)
+                aenv.update(env)
+            result = ''.join(atom.resolve(aenv) for atom in atoms)
 
         new_values[name] = result
 

omlish/{json.py → serde/json.py}

@@ -125,7 +125,7 @@ import functools
 import json as _json
 import typing as ta
 
-from . import lang
+from .. import lang
 
 
 if ta.TYPE_CHECKING:
@@ -160,6 +160,7 @@ PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
 dump_pretty: ta.Callable[..., bytes] = functools.partial(dump, **PRETTY_KWARGS)  # type: ignore
 dumps_pretty: ta.Callable[..., str] = functools.partial(dumps, **PRETTY_KWARGS)
 
+
 ##