systempy 0.1.1__py3-none-any.whl

systempy/__init__.py

@@ -0,0 +1,35 @@
+from .libsystempy import (
+    DIRECTION,
+    ROLE,
+    register_hook_after,
+    register_hook_before,
+    register_target_method,
+)
+from .target import AsyncMixinABC, SyncMixinABC, Target
+from .unit import (
+    AsyncScriptUnit,
+    DaemonUnit,
+    EventWaitUnit,
+    LoopUnit,
+    ReplUnit,
+    ScriptUnit,
+    Unit,
+)
+
+__all__ = (
+    "DIRECTION",
+    "ROLE",
+    "AsyncMixinABC",
+    "AsyncScriptUnit",
+    "DaemonUnit",
+    "EventWaitUnit",
+    "LoopUnit",
+    "ReplUnit",
+    "ScriptUnit",
+    "SyncMixinABC",
+    "Target",
+    "Unit",
+    "register_hook_after",
+    "register_hook_before",
+    "register_target_method",
+)

systempy/libsystempy/__init__.py

@@ -0,0 +1,20 @@
+from .constants import handler_metadata
+from .enums import DIRECTION, ROLE
+from .register import (
+    mark_as_target,
+    register_hook_after,
+    register_hook_before,
+    register_target,
+    register_target_method,
+)
+
+__all__ = (
+    "DIRECTION",
+    "ROLE",
+    "handler_metadata",
+    "mark_as_target",
+    "register_hook_after",
+    "register_hook_before",
+    "register_target",
+    "register_target_method",
+)

systempy/libsystempy/callback_plan.py

@@ -0,0 +1,60 @@
+from collections.abc import Callable, Generator, Iterable
+
+from .check import check_callback_signature
+from .constants import lifecycle_registered_methods
+from .hook_registry import HookRegistry
+from .local_typing import P, R, WeakTypeIterable
+from .register import register_hook_after, register_hook_before
+
+
+def build_callback_plan_hook_iter(
+    cls: type,
+    bases: WeakTypeIterable,
+    reason: Callable[P, R],
+    hook_registry: HookRegistry[P, R],
+) -> Generator[Callable[P, R], None, None]:
+    if reason in hook_registry:
+        next_reasons = hook_registry[reason]
+        for next_reason in next_reasons:
+            assert callable(next_reason)
+            next_registered_methods = lifecycle_registered_methods[next_reason]
+            next_reason_interface = next_registered_methods.interface()
+            direction_handler = next_registered_methods.direction
+            assert next_reason_interface
+
+            if issubclass(cls, next_reason_interface):
+                next_callbacks = direction_handler(bases, next_reason)
+
+                for next_callback in next_callbacks:
+                    check_callback_signature(next_reason, next_callback)
+
+                yield from build_callback_plan_iter(
+                    cls,
+                    bases,
+                    next_reason,
+                    next_callbacks,
+                )
+
+
+def build_callback_plan_iter(
+    cls: type,
+    bases: WeakTypeIterable,
+    reason: Callable[P, R],
+    callbacks: Iterable[Callable[P, R]] = (),
+) -> Generator[Callable[P, R], None, None]:
+    yield from build_callback_plan_hook_iter(cls, bases, reason, register_hook_before)
+    yield from callbacks
+    yield from build_callback_plan_hook_iter(cls, bases, reason, register_hook_after)
+
+
+def build_callback_plan(
+    cls: type,
+    bases: WeakTypeIterable,
+    reason: Callable[P, R],
+    callbacks: Iterable[Callable[P, R]],
+) -> tuple[Callable[P, R], ...]:
+    for func in callbacks:
+        check_callback_signature(reason, func)
+
+    callbacks_total = build_callback_plan_iter(cls, bases, reason, callbacks)
+    return tuple(callbacks_total)

systempy/libsystempy/check.py

@@ -0,0 +1,52 @@
+from collections.abc import Callable
+from inspect import iscoroutinefunction
+
+from .constants import sync_or_async
+from .enums import DIRECTION
+from .local_typing import function_types
+from .register import register_check_method_type
+
+sync_or_async_names = tuple(i.value for i in sync_or_async)
+sync_or_async_names_rev = tuple(reversed(sync_or_async_names))
+
+CHECK_CALLBACK_ERROR_MESSAGE__TEMPLATE = (
+    "{name} must be %sronous function, but {func} is %sronous"
+)
+
+check_callback_signature__error_message: tuple[str, ...] = (
+    CHECK_CALLBACK_ERROR_MESSAGE__TEMPLATE % sync_or_async_names,
+    CHECK_CALLBACK_ERROR_MESSAGE__TEMPLATE % sync_or_async_names_rev,
+)
+
+
+def check_callback_signature(reason: Callable, func: Callable) -> None:
+    """
+    When `reason` is syncronous, `func` have to be syncronous too
+    Asyncronous `reason` executors may to execute both `func` types
+    """
+
+    assert isinstance(reason, function_types)
+    assert isinstance(func, function_types)
+
+    reason_async = iscoroutinefunction(reason)
+    if reason_async:
+        return
+
+    if not iscoroutinefunction(func):
+        return
+
+    template = check_callback_signature__error_message[reason_async]
+
+    error_message = template.format(
+        name=reason.__name__,
+        func=func,
+    )
+
+    raise ValueError(error_message)
+
+
+@register_check_method_type(DIRECTION.GATHER)
+def gather(target: Callable) -> None:
+    if not iscoroutinefunction(target):
+        error_message = "Can not `asyncio.gather` syncronous method"
+        raise ValueError(error_message, target)

systempy/libsystempy/class_role.py

@@ -0,0 +1,32 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Generic, NamedTuple, TypeVar
+from typing import final as typing_final
+
+from .configuration import apply_additional_configuration
+from .register import mark_as_final, mark_as_target, register_target
+
+T = TypeVar("T")
+
+
+class ClassRole(NamedTuple, Generic[T]):
+    app: Callable[[T], T]
+    unit: Callable[[T], T]
+    mixin: Callable[[T], T]
+    target: Callable[[T], T]
+
+
+default_dataclass_kwargs: dict[str, bool] = {
+    "kw_only": True,
+}
+
+nonfinal = dataclass(**default_dataclass_kwargs, init=False, repr=False, eq=False)
+final = dataclass(**default_dataclass_kwargs)
+
+
+class_role = ClassRole[type](
+    lambda cls: final(apply_additional_configuration(mark_as_final(typing_final(cls)))),
+    nonfinal,
+    lambda cls: nonfinal(mark_as_target(cls)),
+    lambda cls: nonfinal(register_target(cls)),
+)

systempy/libsystempy/configuration.py

@@ -0,0 +1,56 @@
+from dataclasses import fields
+from typing import Any
+
+from .constants import lifecycle_additional_configuration
+from .creation import create_partial_handler_generic
+from .local_dataclasses import ClsCFG
+from .local_typing import WeakTypeIterable
+from .misc import get_key_or_create
+from .register import register_addition_cfg_applier
+
+
+@register_addition_cfg_applier
+def stack_method(cls: type, config: ClsCFG) -> None:
+    sm_cfg = config.stack_method
+    create = create_partial_handler_generic(cls)
+
+    for stage_config in sm_cfg.values():
+        create(stage_config)
+
+
+def apply_additional_config(cls: type, config: ClsCFG) -> None:
+    for clscfg_field in fields(config):
+        key = clscfg_field.name
+        apply_cfg_handler = register_addition_cfg_applier[key]
+        apply_cfg_handler(cls, config)
+
+
+def apply_additional_configuration(this_cls: type) -> type:
+    for cls, config in lifecycle_additional_configuration.items():
+        if issubclass(this_cls, cls):
+            apply_additional_config(this_cls, config)
+    return this_cls
+
+
+def update_annotation(
+    clsdict: dict[str, Any],
+    bases: WeakTypeIterable,
+) -> None:
+    annotations: dict[str, type] = get_key_or_create(
+        clsdict,
+        "__annotations__",
+        dict,
+    )
+
+    for base in bases:
+        basedict = vars(base)
+
+        if "__annotations__" not in basedict:
+            continue
+
+        target_annotations: dict[str, type] = basedict["__annotations__"]
+        annotations.update(target_annotations)
+
+        for key in target_annotations:
+            if key in basedict:
+                clsdict[key] = basedict[key]

systempy/libsystempy/constants.py

@@ -0,0 +1,16 @@
+from weakref import WeakKeyDictionary
+
+from .enums import TYPE as _TYPE
+from .local_typing import DisallowedAttrInfo, LFMetadata, LFRegistered, LFTypeConfig
+
+lifecycle_additional_configuration: LFTypeConfig[type] = WeakKeyDictionary()
+lifecycle_registered_methods: LFRegistered = WeakKeyDictionary()
+
+sync_or_async = (_TYPE.SYNC, _TYPE.ASYNC)
+handler_metadata: LFMetadata = WeakKeyDictionary()
+
+
+lifecycle_disallowed_attrs: list[DisallowedAttrInfo] = [
+    ("__init__", "Use `on_init` instead"),
+    ("__post_init__", "Use `on_init` instead"),
+]

systempy/libsystempy/creation.py

@@ -0,0 +1,32 @@
+from collections.abc import Callable
+from functools import partial
+from weakref import ref
+
+from . import extraction
+from .local_dataclasses import GenericHandlerSettings
+from .local_typing import WeakTypeIterable
+
+
+def create_handler_generic(
+    cls_ref: ref[type],
+    bases: WeakTypeIterable,
+    settings: GenericHandlerSettings,
+) -> None:
+    collect = settings.collect()
+    reason = settings.reason()
+    compose = settings.compose()
+    cls = cls_ref()
+    assert collect
+    assert reason
+    assert compose
+    assert cls
+    callbacks = collect(bases, reason)
+    handler = compose(cls, bases, reason, callbacks)
+    setattr(cls, reason.__name__, handler)
+
+
+def create_partial_handler_generic(
+    cls: type,
+) -> Callable[[GenericHandlerSettings], None]:
+    bases = extraction.extract_bases(cls)
+    return partial(create_handler_generic, ref(cls), bases)

systempy/libsystempy/enums.py

@@ -0,0 +1,30 @@
+from enum import Enum, unique
+
+
+@unique
+class DIRECTION(str, Enum):
+    """
+    Public enum containing supported directions. Rely on your IDE's help
+    """
+
+    FORWARD = "forward"
+    BACKWARD = "backward"
+    GATHER = "gather"
+
+
+@unique
+class TYPE(str, Enum):
+    """
+    Private internal enum
+    """
+
+    SYNC = "sync"
+    ASYNC = "async"
+
+
+@unique
+class ROLE(str, Enum):
+    APP = "app"
+    UNIT = "unit"
+    MIXIN = "mixin"
+    TARGET = "target"

systempy/libsystempy/extraction.py

@@ -0,0 +1,88 @@
+from collections.abc import Callable, Coroutine
+from inspect import iscoroutinefunction
+from typing import cast
+from weakref import ref
+
+from .constants import lifecycle_disallowed_attrs, lifecycle_registered_methods
+from .enums import DIRECTION
+from .local_dataclasses import SeparatedLFMethods
+from .local_typing import CTuple, P, R, WeakTypeIterable
+from .register import mark_as_target, register_direction
+
+
+def extract_attrs(iterable: WeakTypeIterable, reason: Callable) -> list[Callable]:
+    result: list[Callable] = []
+    cfg = lifecycle_registered_methods[reason]
+    interface = cfg.interface()
+
+    assert interface
+
+    for cls_ref in iterable:
+        cls = cls_ref()
+        assert cls
+
+        if not issubclass(cls, interface):
+            continue
+
+        cls_dict = cls.__dict__
+
+        if (maybe_val := cls_dict.get(reason.__name__)) is not None:
+            result.append(maybe_val)
+
+    return result
+
+
+@register_direction(DIRECTION.FORWARD)
+@register_direction(DIRECTION.GATHER)
+def callbacks_direct(iterable: WeakTypeIterable, reason: Callable) -> CTuple:
+    callbacks = extract_attrs(iterable, reason)
+    return tuple(callbacks)
+
+
+@register_direction(DIRECTION.BACKWARD)
+def callbacks_reversed(iterable: WeakTypeIterable, reason: Callable) -> CTuple:
+    callbacks = extract_attrs(iterable, reason)
+    callbacks.reverse()
+    return tuple(callbacks)
+
+
+def extract_bases(cls: type) -> WeakTypeIterable:
+    bases = [
+        # ===
+        Base
+        for Base in cls.mro()
+        if Base not in mark_as_target
+    ]
+
+    for base in bases:
+        clsdict = vars(base)
+        for check_attribute, description in lifecycle_disallowed_attrs:
+            if check_attribute in clsdict:
+                message = f"Attribute {check_attribute} is not allowed"
+
+                if description:
+                    message = f"{message}. {description}"
+
+                raise ValueError(message, base)
+
+    first = bases.pop(0)
+    bases.append(first)
+    return tuple(map(ref, bases))
+
+
+def separate_sync_async(
+    iterable: CTuple[P, R | Coroutine[R, None, None]],
+) -> SeparatedLFMethods[P, R]:
+    callbacks_sync: list[Callable[P, R]] = []
+    callbacks_async: list[Callable[P, Coroutine[R, None, None]]] = []
+
+    for callback in iterable:
+        if iscoroutinefunction(callback):
+            callbacks_async.append(callback)
+        else:
+            callbacks_sync.append(cast("Callable[P, R]", callback))
+
+    return SeparatedLFMethods(
+        callbacks_sync=tuple(callbacks_sync),
+        callbacks_async=tuple(callbacks_async),
+    )

systempy/libsystempy/handler_type.py

@@ -0,0 +1,170 @@
+from asyncio import gather
+from collections.abc import Callable, Coroutine
+from inspect import iscoroutinefunction
+
+from .callback_plan import build_callback_plan
+from .constants import handler_metadata
+from .enums import DIRECTION, TYPE
+from .extraction import separate_sync_async
+from .local_dataclasses import CallbackMetadata, SeparatedLFMethods
+from .local_typing import CTuple, MaybeCoro, P, R, WeakTypeIterable
+from .register import register_handler_by_aio
+
+
+def with_repr(
+    group: str,
+    reason: Callable,
+    callbacks: CTuple,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def inner(handler: Callable[P, R]) -> Callable[P, R]:
+        call_order = tuple(".".join(c.__qualname__.split(".")[-2:]) for c in callbacks)
+        handler.__qualname__ = f"{group}[{reason.__name__}]({';'.join(call_order)})"
+        handler_metadata[handler] = CallbackMetadata(call_order)
+        return handler
+
+    return inner
+
+
+# Make closure as minimal as possible to avoid memory leak
+def __handler_sync(
+    callbacks_total: tuple[Callable[P, None], ...],
+    with_current_repr: Callable[[Callable[P, None]], Callable[P, None]],
+) -> Callable[P, None]:
+    @with_current_repr
+    def handler(*args: P.args, **kwargs: P.kwargs) -> None:
+        for callback in callbacks_total:
+            callback(*args, **kwargs)
+
+    return handler
+
+
+@register_handler_by_aio(TYPE.SYNC)
+def handler_sync(
+    cls: type,
+    bases: WeakTypeIterable,
+    reason: Callable[P, None],
+    callbacks: CTuple[P, None],
+) -> Callable[P, None]:
+    callbacks_total = build_callback_plan(cls, bases, reason, callbacks)
+    with_current_repr = with_repr("Sync", reason, callbacks_total)
+    return __handler_sync(callbacks_total, with_current_repr)
+
+
+# Make closure as minimal as possible to avoid memory leak
+def __handler_async(
+    callbacks_total: tuple[Callable[P, MaybeCoro[None]], ...],
+    with_current_repr: Callable[
+        [Callable[P, Coroutine[None, None, None]]],
+        Callable[P, Coroutine[None, None, None]],
+    ],
+) -> Callable[P, Coroutine[None, None, None]]:
+    @with_current_repr
+    async def handler(*args: P.args, **kwargs: P.kwargs) -> None:
+        for callback in callbacks_total:
+            if iscoroutinefunction(callback):
+                await callback(*args, **kwargs)
+            else:
+                callback(*args, **kwargs)
+
+    return handler
+
+
+@register_handler_by_aio(TYPE.ASYNC)
+def handler_async(
+    cls: type,
+    bases: WeakTypeIterable,
+    reason: Callable[P, MaybeCoro[None]],
+    callbacks: CTuple[P, MaybeCoro[None]],
+) -> Callable[P, Coroutine[None, None, None]]:
+    callbacks_total = build_callback_plan(cls, bases, reason, callbacks)
+    with_current_repr = with_repr("Async", reason, callbacks_total)
+    return __handler_async(callbacks_total, with_current_repr)
+
+
+# Make closure as minimal as possible to avoid memory leak
+def __handler_gather_both(
+    separated: SeparatedLFMethods[P, None],
+    with_current_repr: Callable[
+        [Callable[P, Coroutine[None, None, None]]],
+        Callable[P, Coroutine[None, None, None]],
+    ],
+) -> Callable[P, Coroutine[None, None, None]]:
+    @with_current_repr
+    async def handler(*args: P.args, **kwargs: P.kwargs) -> None:
+        for cb in separated.callbacks_sync:
+            cb(*args, **kwargs)
+
+        await gather(*[cb(*args, **kwargs) for cb in separated.callbacks_async])
+
+    return handler
+
+
+# Make closure as minimal as possible to avoid memory leak
+def __handler_gather_async(
+    callbacks_total: tuple[Callable[P, Coroutine[None, None, None]], ...],
+    with_current_repr: Callable[
+        [Callable[P, Coroutine[None, None, None]]],
+        Callable[P, Coroutine[None, None, None]],
+    ],
+) -> Callable[P, Coroutine[None, None, None]]:
+    @with_current_repr
+    async def handler(*args: P.args, **kwargs: P.kwargs) -> None:
+        await gather(*[cb(*args, **kwargs) for cb in callbacks_total])
+
+    return handler
+
+
+# Make closure as minimal as possible to avoid memory leak
+def __handler_gather_sync(
+    callbacks_total: tuple[Callable[P, None], ...],
+    with_current_repr: Callable[
+        [Callable[P, Coroutine[None, None, None]]],
+        Callable[P, Coroutine[None, None, None]],
+    ],
+) -> Callable[P, Coroutine[None, None, None]]:
+    @with_current_repr
+    async def handler(*args: P.args, **kwargs: P.kwargs) -> None:
+        for callback in callbacks_total:
+            callback(*args, **kwargs)
+
+    return handler
+
+
+# Make closure as minimal as possible to avoid memory leak
+def __handler_gather_void(
+    with_current_repr: Callable[
+        [Callable[P, Coroutine[None, None, None]]],
+        Callable[P, Coroutine[None, None, None]],
+    ],
+) -> Callable[P, Coroutine[None, None, None]]:
+    @with_current_repr
+    async def handler(*args: P.args, **kwargs: P.kwargs) -> None: ...
+
+    return handler
+
+
+@register_handler_by_aio(DIRECTION.GATHER)
+def handler_gather(
+    cls: type,
+    bases: WeakTypeIterable,
+    reason: Callable[P, MaybeCoro[None]],
+    callbacks: CTuple[P, MaybeCoro[None]],
+) -> Callable[P, Coroutine[None, None, None]]:
+    callbacks_total = build_callback_plan(cls, bases, reason, callbacks)
+
+    separated = separate_sync_async(callbacks_total)
+
+    if separated.callbacks_sync and separated.callbacks_async:
+        with_current_repr = with_repr("GatherBoth", reason, callbacks_total)
+        return __handler_gather_both(separated, with_current_repr)
+
+    if separated.callbacks_async:
+        with_current_repr = with_repr("GatherAsync", reason, callbacks_total)
+        return __handler_gather_async(separated.callbacks_async, with_current_repr)
+
+    if separated.callbacks_sync:
+        with_current_repr = with_repr("GatherBoth", reason, callbacks_total)
+        return __handler_gather_sync(separated.callbacks_sync, with_current_repr)
+
+    with_current_repr = with_repr("GatherNone", reason, callbacks_total)
+    return __handler_gather_void(with_current_repr)

systempy/libsystempy/hook_registry.py

@@ -0,0 +1,50 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from inspect import iscoroutinefunction
+from typing import (
+    ClassVar,
+)
+from weakref import WeakKeyDictionary
+
+from . import register
+from .enums import DIRECTION
+from .local_dataclasses import BaseRegistry
+from .local_typing import (
+    Decorator,
+    Named,
+    P,
+    R,
+)
+from .misc import get_key_or_create
+from .weak_queue import WeakQueue
+
+
+@dataclass()
+class HookRegistry(BaseRegistry[Callable[P, R], WeakQueue[Callable[P, R]]]):
+    hook_parents: ClassVar = WeakKeyDictionary[Named, Named]()
+
+    __hook_invalid_template = (
+        "You are trying to register executing asyncronous hook %s on the stage "
+        "when event loop is not started or already stopped"
+    )
+
+    def __call__(
+        self,
+        reason: Callable[P, R],
+        direction: DIRECTION | None = None,
+    ) -> Decorator[P, R]:
+        registry = get_key_or_create(self._registry, reason, WeakQueue)
+        lifecycle_method_parent = self.hook_parents.get(reason, reason)
+        parent_syncronous = not iscoroutinefunction(lifecycle_method_parent)
+
+        def inner(func: Callable[P, R]) -> Callable[P, R]:
+            if parent_syncronous and iscoroutinefunction(func):
+                raise ValueError(self.__hook_invalid_template % func)
+
+            if direction is not None:
+                register.register_target_method(direction)(func)
+            self.hook_parents[func] = lifecycle_method_parent
+            registry.append(func)
+            return func
+
+        return inner