omlish 0.0.0.dev1__py3-none-any.whl

omlish/lang/datetimes.py

@@ -0,0 +1,67 @@
+import datetime
+import re
+
+
+def to_seconds(value: datetime.timedelta) -> float:
+    return 86400 * value.days + value.seconds + 0.000001 * value.microseconds
+
+
+def months_ago(date: datetime.date, num: int) -> datetime.date:
+    ago_year = date.year
+    ago_month = date.month - num
+    while ago_month < 1:
+        ago_year -= 1
+        ago_month += 12
+    while ago_month > 12:
+        ago_year += 1
+        ago_month -= 12
+    return datetime.date(ago_year, ago_month, 1)
+
+
+def parse_date(s: str) -> datetime.date:
+    if s.lower() in ['today', 'now']:
+        return datetime.date.today()
+    elif s.lower() == 'yesterday':
+        return datetime.date.today() - datetime.timedelta(days=1)
+    elif s.lower().endswith(' days ago'):
+        num = int(s.split(' ', 1)[0])
+        return datetime.date.today() - datetime.timedelta(days=num)
+    elif s.lower().endswith(' months ago'):
+        months = int(s.split(' ', 1)[0])
+        return months_ago(datetime.date.today(), months)
+    else:
+        return datetime.date(*map(int, s.split('-', 3)))
+
+
+_TIMEDELTA_STR_RE = re.compile(
+    r'^\s*'
+    r'((?P<days>-?\d+)\s*days?,\s*)?'
+    r'(?P<hours>\d?\d):(?P<minutes>\d\d)'
+    r':(?P<seconds>\d\d+(\.\d+)?)'
+    r'\s*$')
+
+
+_TIMEDELTA_DHMS_RE = re.compile(
+    r'^\s*'
+    r'(?P<negative>-)?'
+    r'((?P<days>\d+(\.\d+)?)\s*(d|days?))?'
+    r',?\s*((?P<hours>\d+(\.\d+)?)\s*(h|hours?))?'
+    r',?\s*((?P<minutes>\d+(\.\d+)?)\s*(m|minutes?))?'
+    r',?\s*((?P<seconds>\d+(\.\d+)?)\s*(s|secs?|seconds?))?'
+    r'\s*$')
+
+
+def parse_timedelta(s: str) -> datetime.timedelta:
+    match = _TIMEDELTA_DHMS_RE.match(s)
+    if not match:
+        match = _TIMEDELTA_STR_RE.match(s)
+    if not match:
+        raise ValueError
+    timedelta_kwargs = {
+        k: float(v)
+        for k, v in match.groupdict().items()
+        if k != 'negative' and v is not None}
+    if not timedelta_kwargs:
+        raise ValueError()
+    sign = -1 if match.groupdict().get('negative') else 1
+    return sign * datetime.timedelta(**timedelta_kwargs)

omlish/lang/descriptors.py

@@ -0,0 +1,52 @@
+import typing as ta
+
+
+##
+
+
+BUILTIN_METHOD_DESCRIPTORS = (classmethod, staticmethod)
+
+
+class _MethodDescriptor:
+    pass
+
+
+def is_method_descriptor(obj: ta.Any) -> bool:
+    return isinstance(obj, (*BUILTIN_METHOD_DESCRIPTORS, _MethodDescriptor))
+
+
+def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
+    while is_method_descriptor(fn):
+        fn = fn.__func__  # type: ignore  # noqa
+    return fn
+
+
+##
+
+
+class AccessForbiddenException(Exception):
+
+    def __init__(self, name: ta.Optional[str] = None, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__(*((name,) if name is not None else ()), *args, **kwargs)  # noqa
+        self.name = name
+
+
+class AccessForbiddenDescriptor:
+
+    def __init__(self, name: ta.Optional[str] = None) -> None:
+        super().__init__()
+
+        self._name = name
+
+    def __set_name__(self, owner: ta.Type, name: str) -> None:
+        if self._name is None:
+            self._name = name
+        elif name != self._name:
+            raise NameError(name)
+
+    def __get__(self, instance, owner=None):
+        raise AccessForbiddenException(self._name)
+
+
+def access_forbidden():
+    return AccessForbiddenDescriptor()

omlish/lang/functions.py

@@ -0,0 +1,126 @@
+import functools
+import time
+import typing as ta
+
+from .descriptors import is_method_descriptor
+
+
+T = ta.TypeVar('T')
+
+
+def is_lambda(f: ta.Any) -> bool:
+    l = lambda: 0
+    return isinstance(f, type(l)) and f.__name__ == l.__name__
+
+
+def maybe_call(obj: ta.Any, att: str, *args, default: ta.Any = None, **kwargs) -> ta.Any:
+    try:
+        fn = getattr(obj, att)
+    except AttributeError:
+        return default
+    else:
+        return fn(*args, **kwargs)
+
+
+def unwrap_func(fn: ta.Callable) -> ta.Callable:
+    fn, _ = unwrap_func_with_partials(fn)
+    return fn
+
+
+def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functools.partial]]:
+    ps = []
+    while True:
+        if is_method_descriptor(fn):
+            fn = fn.__func__  # type: ignore
+        elif isinstance(fn, functools.partial):
+            ps.append(fn)
+            fn = fn.func
+        else:
+            nxt = getattr(fn, '__wrapped__', None)
+            if not callable(nxt):
+                break
+            elif nxt is fn:
+                raise TypeError(fn)
+            fn = nxt
+    return fn, ps
+
+
+def raise_(o: BaseException) -> ta.NoReturn:
+    raise o
+
+
+def try_(
+        exc: ta.Union[type[Exception], ta.Iterable[type[Exception]]] = Exception,
+        default: ta.Optional[T] = None,
+) -> ta.Callable[..., T]:
+    def outer(fn):
+        def inner(*args, **kwargs):
+            try:
+                return fn(*args, **kwargs)
+            except exct:
+                return default
+
+        return inner
+
+    exct = (exc,) if isinstance(exc, type) else tuple(exc)
+    return outer
+
+
+def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
+    def rec(*args, **kwargs) -> T:
+        return fn(rec, *args, **kwargs)
+
+    return rec(*args, **kwargs)
+
+
+def identity(obj: T) -> T:
+    return obj
+
+
+class constant(ta.Generic[T]):  # noqa
+
+    def __init__(self, obj: T) -> None:
+        super().__init__()
+
+        self._obj = obj
+
+    def __call__(self) -> T:
+        return self._obj
+
+
+def is_none(o: ta.Any) -> bool:
+    return o is None
+
+
+def is_not_none(o: ta.Any) -> bool:
+    return o is not None
+
+
+class VoidException(Exception):
+    pass
+
+
+class Void:
+
+    def __new__(cls, *args, **kwargs):
+        raise VoidException
+
+    def __init_subclass__(cls, **kwargs):
+        raise VoidException
+
+
+def void(*args, **kwargs) -> ta.NoReturn:
+    raise VoidException
+
+
+def ticking_timeout(
+        s: int | float | None,
+        ex: type[BaseException] | BaseException = TimeoutError,
+) -> ta.Callable[[], None]:
+    if s is None:
+        return lambda: None
+    def tick():  # noqa
+        if time.time() >= deadline:
+            raise ex
+    deadline = time.time() + s
+    return tick

omlish/lang/imports.py

@@ -0,0 +1,153 @@
+import functools
+import importlib
+import sys
+import types
+import typing as ta
+
+from .cached import cached_function
+
+
+##
+
+
+def lazy_import(name: str, package: ta.Optional[str] = None) -> ta.Callable[[], ta.Any]:
+    return cached_function(functools.partial(importlib.import_module, name, package=package))
+
+
+def proxy_import(name: str, package: ta.Optional[str] = None) -> types.ModuleType:
+    omod = None
+
+    def __getattr__(att):
+        nonlocal omod
+        if omod is None:
+            omod = importlib.import_module(name, package=package)
+        return getattr(omod, att)
+
+    lmod = types.ModuleType(name)
+    lmod.__getattr__ = __getattr__  # type: ignore
+    return lmod
+
+
+##
+
+
+_pkg_resources = lazy_import('pkg_resources')
+
+
+def import_module(dotted_path: str) -> types.ModuleType:
+    if not dotted_path:
+        raise ImportError(dotted_path)
+    mod = __import__(dotted_path, globals(), locals(), [])
+    for name in dotted_path.split('.')[1:]:
+        try:
+            mod = getattr(mod, name)
+        except AttributeError:
+            raise AttributeError('Module %r has no attribute %r' % (mod, name))
+    return mod
+
+
+def import_module_attr(dotted_path: str) -> ta.Any:
+    module_name, _, class_name = dotted_path.rpartition('.')
+    mod = import_module(module_name)
+    try:
+        return getattr(mod, class_name)
+    except AttributeError:
+        raise AttributeError('Module %r has no attr %r' % (module_name, class_name))
+
+
+SPECIAL_IMPORTABLE: ta.AbstractSet[str] = frozenset([
+    '__init__.py',
+    '__main__.py',
+])
+
+
+def yield_importable(
+        package_root: str,
+        *,
+        recursive: bool = False,
+        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        include_special: bool = False,
+) -> ta.Iterator[str]:
+    def rec(dir):
+        if dir.split('.')[-1] == '__pycache__':
+            return
+
+        try:
+            module = sys.modules[dir]
+        except KeyError:
+            try:
+                __import__(dir)
+            except ImportError:
+                return
+            module = sys.modules[dir]
+
+        # FIXME: pyox
+        if getattr(module, '__file__', None) is None:
+            return
+
+        for file in _pkg_resources().resource_listdir(dir, '.'):
+            if file.endswith('.py'):
+                if not (include_special or file not in SPECIAL_IMPORTABLE):
+                    continue
+
+                name = dir + '.' + file[:-3]
+                if filter is not None and not filter(name):
+                    continue
+
+                yield name
+
+            elif recursive and '.' not in file:
+                name = dir + '.' + file
+                if filter is not None and not filter(name):
+                    continue
+
+                try:
+                    yield from rec(name)
+                except (ImportError, NotImplementedError):
+                    pass
+
+    yield from rec(package_root)
+
+
+def yield_import_all(
+        package_root: str,
+        *,
+        globals: ta.Optional[dict[str, ta.Any]] = None,
+        locals: ta.Optional[dict[str, ta.Any]] = None,
+        recursive: bool = False,
+        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        include_special: bool = False,
+) -> ta.Iterator[str]:
+    for import_path in yield_importable(
+            package_root,
+            recursive=recursive,
+            filter=filter,
+            include_special=include_special,
+    ):
+        __import__(import_path, globals=globals, locals=locals)
+        yield import_path
+
+
+def import_all(
+        package_root: str,
+        *,
+        recursive: bool = False,
+        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        include_special: bool = False,
+) -> None:
+    for _ in yield_import_all(
+            package_root,
+            recursive=recursive,
+            filter=filter,
+            include_special=include_special,
+    ):
+        pass
+
+
+def try_import(spec: str) -> ta.Optional[types.ModuleType]:
+    s = spec.lstrip('.')
+    l = len(spec) - len(s)
+    try:
+        return __import__(s, globals(), level=l)
+    except ImportError:
+        return None

omlish/lang/iterables.py

@@ -0,0 +1,54 @@
+import itertools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+BUILTIN_SCALAR_ITERABLE_TYPES: tuple[type, ...] = (
+    bytearray,
+    bytes,
+    str,
+)
+
+
+def ilen(it: ta.Iterable) -> int:
+    c = 0
+    for _ in it:
+        c += 1
+    return c
+
+
+def take(n: int, it: ta.Iterable[T]) -> list[T]:
+    return list(itertools.islice(it, n))
+
+
+def exhaust(it: ta.Iterable[ta.Any]) -> None:
+    for _ in it:
+        pass
+
+
+def peek(vs: ta.Iterable[T]) -> ta.Tuple[T, ta.Iterator[T]]:
+    it = iter(vs)
+    v = next(it)
+    return v, itertools.chain(iter((v,)), it)
+
+
+Rangeable: ta.TypeAlias = ta.Union[int, ta.Tuple[int], ta.Tuple[int, int], ta.Iterable[int]]
+
+
+def asrange(i: Rangeable) -> ta.Iterable[int]:
+    if isinstance(i, int):
+        return range(i)
+    elif isinstance(i, tuple):
+        return range(*i)
+    elif isinstance(i, ta.Iterable):
+        return i
+    else:
+        raise TypeError(i)
+
+
+def prodrange(*dims: Rangeable) -> ta.Iterable[ta.Sequence[int]]:
+    if not dims:
+        return []
+    return itertools.product(*map(asrange, dims))

omlish/lang/maybes.py

@@ -0,0 +1,136 @@
+import abc
+import typing as ta
+
+
+T = ta.TypeVar('T')
+U = ta.TypeVar('U')
+
+
+class ValueNotPresentException(BaseException):
+    pass
+
+
+class Maybe(abc.ABC, ta.Generic[T]):
+
+    @property
+    @abc.abstractmethod
+    def present(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def must(self) -> T:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __call__(self) -> T:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __iter__(self) -> ta.Iterator[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __getitem__(self, item: int) -> T:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def if_present(self, consumer: ta.Callable[[T], None]) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def filter(self, predicate: ta.Callable[[T], bool]) -> 'Maybe[T]':
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def map(self, mapper: ta.Callable[[T], U]) -> 'Maybe[U]':
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def flat_map(self, mapper: ta.Callable[[T], 'Maybe[U]']) -> 'Maybe[U]':
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def or_else(self, other: T) -> 'Maybe[T]':
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def or_else_get(self, supplier: ta.Callable[[], T]) -> 'Maybe[T]':
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> 'Maybe[T]':
+        raise NotImplementedError
+
+
+class _Maybe(Maybe[T], tuple):
+
+    @property
+    def present(self) -> bool:
+        return bool(self)
+
+    def must(self) -> T:
+        if not self:
+            raise ValueNotPresentException
+        return self[0]
+
+    __call__ = must
+
+    def __iter__(self) -> ta.Iterator[T]:
+        raise TypeError
+
+    locals()['__iter__'] = tuple.__iter__
+
+    def __getitem__(self, item: int) -> T:  # type: ignore
+        raise TypeError
+
+    locals()['__getitem__'] = tuple.__getitem__
+
+    def if_present(self, consumer: ta.Callable[[T], None]) -> None:
+        if self:
+            consumer(self[0])
+
+    def filter(self, predicate: ta.Callable[[T], bool]) -> Maybe[T]:
+        return self if self and predicate(self[0]) else _empty
+
+    def map(self, mapper: ta.Callable[[T], U]) -> Maybe[U]:
+        if self:
+            value = mapper(self[0])
+            if value is not None:
+                return just(value)
+        return _empty  # noqa
+
+    def flat_map(self, mapper: ta.Callable[[T], Maybe[U]]) -> Maybe[U]:
+        if self:
+            value = mapper(self[0])
+            if not isinstance(value, Maybe):
+                raise TypeError(value)
+            return value
+        return _empty  # noqa
+
+    def or_else(self, other: T) -> Maybe[T]:
+        return self if self else just(other)
+
+    def or_else_get(self, supplier: ta.Callable[[], T]) -> Maybe[T]:
+        return self if self else just(supplier())
+
+    def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> Maybe[T]:
+        if self:
+            return self
+        raise exception_supplier()
+
+
+def just(v: T) -> Maybe[T]:
+    return tuple.__new__(_Maybe, (v,))  # noqa
+
+
+_empty = tuple.__new__(_Maybe, ())
+
+
+def empty() -> Maybe[T]:
+    return _empty  # noqa
+
+
+def maybe(o: ta.Optional[T]) -> Maybe[T]:
+    if o is None:
+        return _empty  # noqa
+    return just(o)

omlish/lang/objects.py

@@ -0,0 +1,103 @@
+import types
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def attr_repr(obj: ta.Any, *attrs: str) -> str:
+    return '%s(%s)' % (
+        type(obj).__name__,
+        ', '.join('%s=%r' % (attr, getattr(obj, attr)) for attr in attrs))
+
+
+def arg_repr(*args, **kwargs) -> str:
+    return ', '.join(*(
+        list(map(repr, args)) +
+        [f'{k}={repr(v)}' for k, v in kwargs.items()]
+    ))
+
+
+##
+
+
+def new_type(
+        name: str,
+        bases: ta.Sequence[ta.Any],
+        namespace: ta.Mapping[str, ta.Any],
+        **kwargs
+) -> ta.Type:
+    return types.new_class(
+        name,
+        tuple(bases),
+        kwds=kwargs,
+        exec_body=lambda ns: ns.update(namespace),
+    )
+
+
+def super_meta(
+        super_meta: ta.Any,
+        meta: ta.Type,
+        name: str,
+        bases: ta.Sequence[ta.Any],
+        namespace: ta.MutableMapping[str, ta.Any],
+        **kwargs
+) -> ta.Type:
+    """Per types.new_class"""
+    resolved_bases = types.resolve_bases(bases)
+    if resolved_bases is not bases:
+        if '__orig_bases__' in namespace:
+            raise TypeError((bases, resolved_bases))
+        namespace['__orig_bases__'] = bases
+    return super_meta.__new__(meta, name, resolved_bases, dict(namespace), **kwargs)
+
+
+##
+
+
+class SimpleProxy(ta.Generic[T]):
+
+    class Descriptor:
+
+        def __init__(self, attr: str) -> None:
+            super().__init__()
+            self._attr = attr
+
+        def __get__(self, instance, owner=None):
+            if instance is None:
+                return self
+            return getattr(object.__getattribute__(instance, '__wrapped__'), self._attr)
+
+        def __set__(self, instance, value):
+            if instance is None:
+                return self
+            setattr(object.__getattribute__(instance, '__wrapped__'), self._attr, value)
+
+        def __delete__(self, instance):
+            if instance is None:
+                return self
+            delattr(object.__getattribute__(instance, '__wrapped__'), self._attr)
+
+    __wrapped_attrs__: ta.Iterable[str] = set()
+
+    def __init__(self, wrapped: T) -> None:
+        super().__init__()
+        object.__setattr__(self, '__wrapped__', wrapped)
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        for attr in cls.__wrapped_attrs__:
+            setattr(cls, attr, SimpleProxy.Descriptor(attr))
+
+    def __getattr__(self, item):
+        return getattr(object.__getattribute__(self, '__wrapped__'), item)
+
+    def __setattr__(self, name, value):
+        setattr(object.__getattribute__(self, '__wrapped__'), name, value)
+
+    def __delattr__(self, item):
+        delattr(object.__getattribute__(self, '__wrapped__'), item)