melony 1.0.1__tar.gz

melony-1.0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: melony
+Version: 1.0.1
+Summary: Multisync task manager for python
+Home-page: https://melony-python.com/
+Author: wimble3
+Author-email: wimble@internet.ru
+License: UNKNOWN
+Project-URL: Documentation, https://melony-python.com/docs
+Keywords: task manager python melony
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+UNKNOWN
+

melony-1.0.1/melony/core/brokers.py

@@ -0,0 +1,104 @@
+import asyncio
+
+from abc import ABC, abstractmethod
+from functools import wraps
+from inspect import signature
+from typing import Callable, ParamSpec, TypeVar, final, overload
+
+from melony.core.consumers import BaseConsumer
+from melony.core.publishers import Publisher
+from melony.core.task_wrappers import AsyncTaskWrapper, SyncTaskWrapper, TaskWrapper
+
+_TaskParams = ParamSpec("_TaskParams")
+_TaskResult = TypeVar("_TaskResult")
+
+
+class BaseBroker(ABC):
+    @property
+    @abstractmethod
+    def publisher(self) -> Publisher:
+        ...
+
+    @property
+    @abstractmethod
+    def consumer(self) -> BaseConsumer:
+        ...
+
+    @overload
+    def task(
+        self,
+        func: Callable[_TaskParams, _TaskResult]
+    ) -> Callable[_TaskParams, TaskWrapper]:
+        ...
+    
+    @overload
+    def task(
+        self,
+        *, 
+        retries: int = 1,
+        retry_timeout: int = 0
+    ) -> Callable[
+            [Callable[_TaskParams, _TaskResult]],  # type: ignore
+            Callable[_TaskParams, TaskWrapper]
+        ]:
+        ...
+
+    @final
+    def task(
+        self,
+        func: Callable[_TaskParams, _TaskResult] | None = None,
+        *,
+        retries: int = 1,
+        retry_timeout: int = 0,
+    ) -> Callable[_TaskParams, TaskWrapper] | Callable[[Callable], Callable]:
+        self._validate_params(retries, retry_timeout)
+        def _decorate(  # noqa: WPS430
+            func: Callable[_TaskParams, _TaskResult]
+        ) -> Callable[_TaskParams, TaskWrapper]:
+            @wraps(func)
+            def wrapper(
+                *args: _TaskParams.args,
+                **kwargs: _TaskParams.kwargs
+            ) -> TaskWrapper:
+                sig = signature(func)
+                bound = sig.bind(*args, **kwargs)
+                bound.apply_defaults()
+
+                if asyncio.iscoroutinefunction(func):
+                    return AsyncTaskWrapper(
+                        func=func,
+                        broker=self,
+                        bound_args=bound.arguments,
+                        retries=retries,
+                        retry_timeout=retry_timeout
+                    )
+                else:
+                    return SyncTaskWrapper(
+                        func=func,
+                        broker=self,
+                        bound_args=bound.arguments,
+                        retries=retries,
+                        retry_timeout=retry_timeout
+                    )
+
+            wrapper.__annotations__ = {
+                **func.__annotations__,
+                "return": AsyncTaskWrapper
+            }
+            return wrapper
+
+        if func is None:
+            return _decorate
+        else:
+            return _decorate(func)
+
+    @final
+    def _validate_params(self, retries: int, retry_timeout: int) -> None:
+        if retries <= 0:
+            raise ValueError(
+                "Parameter 'retries' must be positive integer (without zero)"
+            )
+        if retry_timeout < 0:
+            raise ValueError(
+                "Parameter 'retry_timeout' must be positive integer or zero"
+            )

melony-1.0.1/melony/core/consts.py

@@ -0,0 +1,5 @@
+from typing import Final
+
+
+REDIS_QUEUE_NAME: Final[str] = "melony_tasks"
+REDIS_RESULT_BACKEND_KEY: Final[str] = "melony_result_backend:"

melony-1.0.1/melony/core/consumers.py

@@ -0,0 +1,217 @@
+import asyncio
+import multiprocessing
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import Sequence, final
+from redis.exceptions import ConnectionError
+
+from melony.core.dto import FilteredTasksDTO, TaskExecResultsDTO
+from melony.core.publishers import IAsyncPublisher, ISyncPublisher
+from melony.core.result_backends import (
+    IAsyncResultBackendSaver,
+    IResultBackend,
+    ISyncResultBackendSaver
+)
+from melony.core.task_executor import AsyncTaskExecutor, SyncTaskExecutor
+from melony.core.tasks import Task
+from melony.logger import log_error, log_info
+
+
+class BaseConsumer:
+    @final
+    def _filter_tasks_by_execution_time(
+        self,
+        tasks: Sequence[Task],
+        consumer_id
+    ) -> FilteredTasksDTO:
+        tasks_to_execute: list[Task] = []
+        tasks_to_push_back: list[Task] = []
+        current_timestamp = datetime.timestamp(datetime.now())
+        
+        for task in tasks:
+            task_execution_timestamp = task.get_execution_timestamp()
+            if task_execution_timestamp < current_timestamp:
+                tasks_to_execute.append(task)
+            else:
+                tasks_to_push_back.append(task)
+        
+        log_info(f"@@@ {len(tasks_to_execute)=}", consumer_id=consumer_id)
+        return FilteredTasksDTO(
+            tasks_to_execute=tasks_to_execute,
+            tasks_to_push_back=tasks_to_push_back
+        )
+
+
+class BaseAsyncConsumer(ABC, BaseConsumer):  # noqa: WPS214
+    def __init__(
+        self,
+        publisher: IAsyncPublisher,
+        result_backend: IResultBackend | None = None
+    ) -> None:
+        self._publisher = publisher
+        self._connection = self._publisher.connection
+        self._result_backend = result_backend
+
+        result_backend_saver = result_backend.saver if result_backend else None
+        assert isinstance(result_backend_saver, IAsyncResultBackendSaver)
+        
+        self._task_executor = AsyncTaskExecutor(
+            connection=self._connection,
+            result_backend_saver=result_backend_saver
+        )
+
+
+    @final
+    async def start_consume(self, processes: int = 1) -> None:
+        if processes < 1:
+            raise ValueError("Param 'processes' must be positive integer (without zero)")
+
+        if processes == 1:
+            await self._consumer_loop()
+            return
+
+        for process_num in range(processes):
+            process = multiprocessing.Process(
+                name=f"melony-process-{process_num}",
+                target=self._run_consumer_in_process,
+                args=(process_num,),
+                daemon=False
+            )
+            process.start()
+
+    @abstractmethod
+    async def _pop_tasks(self) -> Sequence[Task]:
+        ...
+
+    @final
+    async def _consumer_loop(self, consumer_id: int = 1) -> None:
+        log_info("Start listening...", consumer_id=consumer_id)
+        while True:
+            try:
+                await self._consumer_loop_iteration(consumer_id)
+            except ConnectionError as exc:
+                log_error(f"Redis connection error", exc=exc)
+                break
+            except Exception as exc:
+                log_error(f"Unexpected error at consuming loop", exc=exc)
+                break
+
+    @final
+    async def _consumer_loop_iteration(self, consumer_id) -> None:
+        tasks = await self._pop_tasks()
+        filtered_tasks = self._filter_tasks_by_execution_time(tasks, consumer_id)
+        await self._push_bulk(tasks=filtered_tasks.tasks_to_push_back)
+        wait_task_results = await self._task_executor.execute_tasks(
+            tasks=filtered_tasks.tasks_to_execute
+        )
+        await self._retry_policy(wait_task_results)
+
+    @final
+    async def _push_bulk(self, tasks: Sequence[Task]) -> None:
+        push_coroutines = [self._publisher.push(task) for task in tasks]
+        await asyncio.gather(*[coro for coro in push_coroutines if coro is not None])
+
+    @final
+    async def _retry_policy(
+        self,
+        tasks_exec_results: TaskExecResultsDTO
+    ) -> None:
+        tasks_to_push_back: list[Task] = []
+        for task_to_retry in tasks_exec_results.tasks_to_retry:
+            if task_to_retry._meta.retries_left:
+                if task_to_retry.retry_timeout:
+                    task_to_retry._meta.timestamp += task_to_retry.retry_timeout
+                tasks_to_push_back.append(task_to_retry)
+
+        await self._push_bulk(tasks_to_push_back)
+
+    @final
+    def _run_consumer_in_process(
+        self,
+        consumer_id: int = 0
+    ) -> None:
+        asyncio.run(self._consumer_loop(consumer_id=consumer_id))
+
+
+class BaseSyncConsumer(ABC, BaseConsumer):
+    def __init__(
+        self,
+        publisher: ISyncPublisher,
+        result_backend: IResultBackend | None = None
+    ) -> None:
+        self._publisher = publisher
+        self._connection = self._publisher.connection
+        self._result_backend = result_backend
+
+        result_backend_saver = result_backend.saver if result_backend else None
+        assert isinstance(result_backend_saver, ISyncResultBackendSaver)
+
+        self._task_executor = SyncTaskExecutor(
+            connection=self._connection,
+            result_backend_saver=result_backend_saver
+        )
+
+    @final
+    def start_consume(self, processes: int = 1) -> None:
+        if processes < 1:
+            raise ValueError("Param 'processes' must be positive integer (without zero)")
+
+        if processes == 1:
+            self._consumer_loop()
+            return
+
+        for process_num in range(processes):
+            process = multiprocessing.Process(
+                name=f"melony-process-{process_num}",
+                target=self._consumer_loop,
+                args=(process_num,),
+                daemon=False
+            )
+            process.start()
+
+    @abstractmethod
+    def _pop_tasks(self) -> Sequence[Task]:
+        ...
+
+    @final
+    def _consumer_loop(self, consumer_id: int = 1) -> None:
+        log_info("Start listening...", consumer_id=consumer_id)
+        while True:
+            try:
+                self._consumer_loop_iteration(consumer_id)
+            except ConnectionError as exc:
+                log_error(f"Redis connection error", exc=exc)
+                break
+            except Exception as exc:
+                log_error(f"Unexpected error at consuming loop", exc=exc)
+                break
+
+    @final
+    def _consumer_loop_iteration(self, consumer_id) -> None:
+        tasks = self._pop_tasks()
+        filtered_tasks = self._filter_tasks_by_execution_time(tasks, consumer_id)
+        self._push_bulk(tasks=filtered_tasks.tasks_to_push_back)
+        wait_task_results = self._task_executor.execute_tasks(
+            tasks=filtered_tasks.tasks_to_execute
+        )
+        self._retry_policy(wait_task_results)
+
+    @final
+    def _push_bulk(self, tasks: Sequence[Task]) -> None:
+        for task in tasks:
+            self._publisher.push(task)
+
+    @final
+    def _retry_policy(
+        self,
+        tasks_exec_results: TaskExecResultsDTO
+    ) -> None:
+        tasks_to_push_back: list[Task] = []
+        for task_to_retry in tasks_exec_results.tasks_to_retry:
+            if task_to_retry._meta.retries_left:
+                if task_to_retry.retry_timeout:
+                    task_to_retry._meta.timestamp += task_to_retry.retry_timeout
+                tasks_to_push_back.append(task_to_retry)
+
+        self._push_bulk(tasks_to_push_back)

melony-1.0.1/melony/core/dto.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from typing import Any, Sequence
+
+from melony.core.tasks import Task
+
+
+@dataclass(frozen=True, kw_only=True)
+class FilteredTasksDTO:
+    tasks_to_execute: Sequence[Task]
+    tasks_to_push_back: Sequence[Task]
+
+
+@dataclass(frozen=True, kw_only=True)
+class TaskResultDTO:
+    task: Task
+    task_result: Any
+
+
+@dataclass(frozen=True, kw_only=True)
+class TaskExecResultsDTO:
+    tasks_with_result: Sequence[TaskResultDTO]
+    tasks_to_retry: Sequence[Task]

melony-1.0.1/melony/core/json_task_converter.py

@@ -0,0 +1,63 @@
+from abc import ABC, abstractmethod
+import json
+
+from melony.core.brokers import BaseBroker
+from melony.core.task_finders import find_task_func
+from melony.core.tasks import _TaskMeta, AsyncTask, SyncTask, Task
+
+
+class _BaseJsonTaskConverter(ABC):
+    @abstractmethod
+    def deserialize_task(
+        self,
+        serialized_task: str,
+        broker: BaseBroker
+    ) -> Task:
+        ...
+
+    def serialize_task(self, task: Task) -> str:
+        return task.as_json()
+
+
+class AsyncJsonTaskConverter(_BaseJsonTaskConverter):
+    def deserialize_task(
+        self,
+        serialized_task: str,
+        broker: BaseBroker
+    ) -> Task:
+        task_dict = json.loads(serialized_task)
+        task_func_path = task_dict["func_path"]
+        task_func = find_task_func(task_func_path)
+        return AsyncTask(
+            task_id=task_dict["task_id"],
+            kwargs=task_dict["kwargs"],
+            countdown=task_dict["countdown"],
+            func=task_func,
+            func_path=task_func_path,
+            broker=broker,
+            retries=task_dict["retries"],
+            retry_timeout=task_dict["retry_timeout"],
+            _meta=_TaskMeta(**task_dict["_meta"])
+        )
+
+
+class SyncJsonTaskConverter(_BaseJsonTaskConverter):
+    def deserialize_task(
+        self,
+        serialized_task: str,
+        broker: BaseBroker
+    ) -> Task:
+        task_dict = json.loads(serialized_task)
+        task_func_path = task_dict["func_path"]
+        task_func = find_task_func(task_func_path)
+        return SyncTask(
+            task_id=task_dict["task_id"],
+            kwargs=task_dict["kwargs"],
+            countdown=task_dict["countdown"],
+            func=task_func,
+            func_path=task_func_path,
+            broker=broker,
+            retries=task_dict["retries"],
+            retry_timeout=task_dict["retry_timeout"],
+            _meta=_TaskMeta(**task_dict["_meta"])
+        )

melony-1.0.1/melony/core/publishers.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+from redis.asyncio import Redis
+from redis import Redis as SyncRedis
+
+from melony.core.tasks import Task
+
+
+type Publisher = IAsyncPublisher | ISyncPublisher
+
+
+class IAsyncPublisher(ABC):
+    @property
+    @abstractmethod
+    def connection(self) -> Redis:
+        ...
+
+    @abstractmethod
+    async def push(self, task: Task) -> None:
+        ...
+
+class ISyncPublisher(ABC):
+    @property
+    @abstractmethod
+    def connection(self) -> SyncRedis:
+        ...
+
+    @abstractmethod
+    def push(self, task: Task) -> None:
+        ...

melony-1.0.1/melony/core/result_backends.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import Sequence
+
+from melony.core.dto import TaskResultDTO
+
+
+type ResultBackendSaver = IAsyncResultBackendSaver | ISyncResultBackendSaver
+
+
+class IAsyncResultBackendSaver(ABC):
+    @abstractmethod
+    async def save_results(self, task_results: Sequence[TaskResultDTO]) -> None:
+        ...
+
+class ISyncResultBackendSaver(ABC):
+    @abstractmethod
+    def save_results(self, task_results: Sequence[TaskResultDTO]) -> None:
+        ...
+
+class IResultBackend(ABC):
+    @property
+    @abstractmethod
+    def saver(self) -> ResultBackendSaver:
+        ...

melony-1.0.1/melony/core/task_executor.py

@@ -0,0 +1,127 @@
+import asyncio
+
+from collections.abc import Iterable
+from typing import Any, Sequence, final
+from redis.asyncio import Redis
+from redis import Redis as SyncRedis
+
+from melony.core.dto import TaskResultDTO, TaskExecResultsDTO
+from melony.core.result_backends import IAsyncResultBackendSaver, IResultBackend, ISyncResultBackendSaver
+from melony.core.tasks import Task
+from melony.logger import log_error, log_info
+
+
+@final
+class AsyncTaskExecutor:
+    def __init__(
+        self,
+        connection: Redis,
+        result_backend_saver: IAsyncResultBackendSaver | None = None
+    ) -> None:
+        self._connection = connection
+        self._result_backend = result_backend_saver
+
+    @final
+    async def execute_tasks(self, tasks: Sequence[Task]) -> TaskExecResultsDTO:
+        task_map: dict[asyncio.Task, Task] = {}
+        asyncio_tasks: list[asyncio.Task] = []
+        
+        for task in tasks:
+            asyncio_task = asyncio.create_task(task.execute())
+            task_map[asyncio_task] = task
+            asyncio_tasks.append(asyncio_task)
+            if task._meta.retries_left:
+                task._meta.retries_left -= 1
+        
+        tasks_exec_results = await self._asyncio_wait_tasks(
+            pending=asyncio_tasks,
+            task_map=task_map
+        )
+        return tasks_exec_results
+
+    @final
+    async def _asyncio_wait_tasks(  # noqa: WPS210, WPS231
+        self,
+        pending: Iterable[asyncio.Task],
+        task_map: dict[asyncio.Task, Task]
+    ) -> TaskExecResultsDTO:
+        tasks_to_retry: list[Task] = []
+        tasks_done: list[TaskResultDTO] = []
+        while pending:
+            done, pending = await asyncio.wait(
+                pending, return_when=asyncio.FIRST_COMPLETED
+            )
+            for completed_asyncio_task in done:
+                task = task_map[completed_asyncio_task]
+                task_result = self._get_task_result(asyncio_task=completed_asyncio_task)
+                if isinstance(task_result, BaseException):
+                    log_error(
+                        f"Task with id {task.task_id} has been executed with error: "
+                        f"{task_result}",
+                        exc=task_result
+                    )
+                    tasks_to_retry.append(task)
+                    continue
+                log_info(
+                    f"Task with id '{task.task_id}' completed with result {task_result=}"
+                )
+                tasks_done.append(TaskResultDTO(task=task, task_result=task_result))
+            if self._result_backend:
+                await self._result_backend.save_results(task_results=tasks_done)
+        return TaskExecResultsDTO(
+            tasks_with_result=tasks_done,
+            tasks_to_retry=tasks_to_retry
+        )
+
+    @final
+    def _get_task_result(self, asyncio_task: asyncio.Task) -> Any:  # TODO: typing
+        task_exc = asyncio_task.exception()
+        if task_exc:
+            return task_exc
+        task_result = asyncio_task.result()
+        return task_result
+
+
+@final
+class SyncTaskExecutor:
+    def __init__(
+        self,
+        connection: SyncRedis,
+        result_backend_saver: ISyncResultBackendSaver | None = None
+    ) -> None:
+        self._connection = connection
+        self._result_backend_saver = result_backend_saver
+
+    @final
+    def execute_tasks(self, tasks: Sequence[Task]) -> TaskExecResultsDTO:
+        tasks_to_retry: list[Task] = []
+        tasks_done: list[TaskResultDTO] = []
+        for task in tasks:
+            if task._meta.retries_left:
+                task._meta.retries_left -= 1
+            try:
+                task_result = task.execute()
+            except Exception as exc:
+                task_result = exc
+
+            if isinstance(task_result, BaseException):
+                log_error(
+                    f"Task with id '{task.task_id}' has been executed with error: "
+                    f"{task_result}",
+                    exc=task_result
+                )
+                tasks_to_retry.append(task)
+                continue
+
+            log_info(
+                f"Task with id '{task.task_id}' completed with result {task_result=}"
+            )
+            tasks_done.append(TaskResultDTO(task=task, task_result=task_result))
+
+            if self._result_backend_saver:
+                self._result_backend_saver.save_results(task_results=tasks_done)
+        
+        return TaskExecResultsDTO(
+            tasks_with_result=tasks_done,
+            tasks_to_retry=tasks_to_retry
+        )

melony-1.0.1/melony/core/task_finders.py

@@ -0,0 +1,21 @@
+import importlib
+
+from typing import Callable
+
+
+def find_task_func(func_path: str) -> Callable:
+    try:
+        return _find_func(func_path)
+    except (ImportError, AttributeError, ValueError) as exc:
+        raise ImportError(f"Cannot import function '{func_path}': {exc}")
+    # TODO: check that its Melony Task
+
+def _find_func(func_path: str) -> Callable:
+    module_name, func_name = func_path.rsplit(".", 1)
+    module = importlib.import_module(module_name)
+    func = getattr(module, func_name)
+    
+    if not callable(func):
+        raise ValueError(f"'{func_name}' is not callable")
+        
+    return func

melony-1.0.1/melony/core/task_wrappers.py

@@ -0,0 +1,87 @@
+from collections.abc import Awaitable, Callable
+from inspect import signature
+from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar, final
+from uuid import uuid4
+
+from melony.core.tasks import AsyncTask, SyncTask, Task
+
+if TYPE_CHECKING:
+    from melony.core.brokers import BaseBroker
+
+
+type TaskWrapper = AsyncTaskWrapper | SyncTaskWrapper
+
+_TaskParams = ParamSpec("_TaskParams")
+_TaskResult = TypeVar("_TaskResult")
+
+
+class _BaseTaskWrapper(Awaitable):
+    @final
+    def __init__(
+        self,
+        func: Callable[_TaskParams, _TaskResult],
+        broker: "BaseBroker",
+        bound_args: dict[str, Any],
+        retries: int,
+        retry_timeout: int,
+    ) -> None:
+        self._func = func
+        self._broker = broker
+        self._sig = signature(func)
+        self._bound_args = bound_args or {}
+        self._func_path = f"{func.__module__}.{func.__qualname__}"
+        self._retries = retries
+        self._retry_timeout = retry_timeout
+
+    @final
+    def __call__(
+        self,
+        *args: _TaskParams.args,  # type: ignore
+        **kwargs: _TaskParams.kwargs
+    ) -> "_BaseTaskWrapper":
+        bound = self._sig.bind(*args, **kwargs)
+        bound.apply_defaults()
+        self._bound_args = bound.arguments
+        return self
+
+    @final
+    def __await__(self) -> Any:
+        raise RuntimeError(
+            "Task cannot be awaited, did you forget to call .delay()?"
+        )
+
+@final
+class AsyncTaskWrapper(_BaseTaskWrapper):
+    async def delay(self, countdown: int = 0) -> Task:
+        from melony.core.publishers import IAsyncPublisher
+        assert isinstance(self._broker.publisher, IAsyncPublisher)
+        task = AsyncTask(
+            task_id=str(uuid4()),
+            func=self._func,
+            func_path=self._func_path,
+            kwargs=self._bound_args,
+            broker=self._broker,
+            countdown=countdown,
+            retries=self._retries,
+            retry_timeout=self._retry_timeout
+        )
+        await self._broker.publisher.push(task)
+        return task
+
+@final
+class SyncTaskWrapper(_BaseTaskWrapper):
+    def delay(self, countdown: int = 0) -> Task:
+        from melony.core.publishers import ISyncPublisher
+        assert isinstance(self._broker.publisher, ISyncPublisher)
+        task = SyncTask(
+            task_id=str(uuid4()),
+            func=self._func,
+            func_path=self._func_path,
+            kwargs=self._bound_args,
+            broker=self._broker,
+            countdown=countdown,
+            retries=self._retries,
+            retry_timeout=self._retry_timeout
+        )
+        self._broker.publisher.push(task)
+        return task

melony-1.0.1/melony/core/tasks.py

@@ -0,0 +1,121 @@
+import json
+
+from datetime import datetime
+from dataclasses import asdict, dataclass, field
+from inspect import unwrap
+from typing import (
+    Callable,
+    Any,
+    TYPE_CHECKING,
+    final,
+    Final
+)
+
+
+if TYPE_CHECKING:
+    from melony.core.brokers import BaseBroker
+
+type Task = AsyncTask | SyncTask
+
+
+_MAX_COUNTDOWN_SEC: Final[int] = 900
+_MAX_COUNTDOWN_MIN: Final[float] = _MAX_COUNTDOWN_SEC / 60
+
+
+@final
+@dataclass(kw_only=True)
+class _TaskMeta:
+    retries_left: int | None = None
+    timestamp: float = field(default_factory=lambda: datetime.timestamp(datetime.now()))
+
+
+@dataclass(frozen=True, kw_only=True)
+class _BaseTask:
+    task_id: str
+    kwargs: dict[str, Any]
+    countdown: int
+    retries: int
+    retry_timeout: int
+
+    _meta: _TaskMeta = field(default_factory=_TaskMeta)
+
+    @final
+    def __post_init__(self) -> None:
+        self._validate_countdown()
+        self._set_retries_left_to_meta()
+
+    @final
+    @property
+    def timestamp(self) -> float:
+        return self._meta.timestamp
+
+    @final
+    def get_execution_timestamp(self) -> float:
+        return self.timestamp + self.countdown
+
+    @final
+    def _validate_countdown(self) -> None:
+        if self.countdown < 0:
+            raise ValueError("Countdown cannot be negative")
+        elif self.countdown >= _MAX_COUNTDOWN_SEC:
+            raise ValueError(
+                f"Countdown cannot be greater than {_MAX_COUNTDOWN_SEC} "
+                f"({_MAX_COUNTDOWN_MIN} minutes)"
+            )
+
+    @final
+    def _set_retries_left_to_meta(self) -> None:
+        if not self._meta.retries_left:
+            self._meta.retries_left = self.retries
+
+
+@final
+@dataclass(frozen=True, kw_only=True)
+class _TaskJSONSerializable(_BaseTask):
+    func_name: str
+    func_path: str
+
+@dataclass(frozen=True, kw_only=True)
+class _Task(_BaseTask):
+    func: Callable
+    func_path: str
+    broker: "BaseBroker"
+
+    @final
+    def as_json_serializable_obj(self) -> _TaskJSONSerializable:
+        return _TaskJSONSerializable(
+            task_id=self.task_id,
+            kwargs=self.kwargs,
+            countdown=self.countdown,
+            func_name=self.func.__name__,
+            func_path=self.func_path,
+            retries=self.retries,
+            retry_timeout=self.retry_timeout,
+            _meta=self._meta
+        )
+
+    @final
+    def as_dict(self) -> dict[str, Any]:
+        return asdict(self.as_json_serializable_obj())
+
+    @final
+    def as_json(self) -> str:
+        json_str = json.dumps(self.as_dict())
+        return json_str
+
+
+@final
+@dataclass(frozen=True, kw_only=True)
+class AsyncTask(_Task):
+    async def execute(self) -> Any:
+        unwrapped_func = unwrap(self.func)
+        task_result = await unwrapped_func(**self.kwargs)
+        return task_result
+
+@final
+@dataclass(frozen=True, kw_only=True)
+class SyncTask(_Task):
+    def execute(self) -> Any:
+        unwrapped_func = unwrap(self.func)
+        task_result = unwrapped_func(**self.kwargs)
+        return task_result

melony-1.0.1/melony/logger.py

@@ -0,0 +1,42 @@
+import traceback
+
+from datetime import datetime
+from logging import getLogger
+from typing import Final
+
+
+_logger = getLogger(__name__)
+_MELONY_LOG_PREFIX: Final[str] = "[Melony]"
+_DEBUG = True  # Toggle this for debugging via print python function  TODO: to env
+_WRAP_LINE_WIDTH: Final[int] = 60
+
+
+def log_info(message: str, consumer_id: int | None = None) -> None:
+    if _DEBUG:
+        if consumer_id is None:
+            print(f"{_MELONY_LOG_PREFIX}[INFO][{datetime.now()}]: {message}")  # noqa: WPS421, WPS226
+        else:
+            print(  # noqa: WPS421
+                f"{_MELONY_LOG_PREFIX}[INFO][consumer-{consumer_id}][{datetime.now()}]: "  # noqa: WPS226
+                f"{message}"
+            )
+    else:
+        if consumer_id is None:
+            _logger.info(f"{_MELONY_LOG_PREFIX}[INFO]: {message}")
+        else:
+            _logger.info(
+                f"{_MELONY_LOG_PREFIX}[INFO][consumer-{consumer_id}]: {message}"
+            )
+
+
+
+def log_error(message: str, exc: BaseException | None = None) -> None:
+    if _DEBUG:
+        print(f"{_MELONY_LOG_PREFIX}[ERROR][{datetime.now()}]: {message}")  # noqa: WPS421
+        if exc:
+            formatted_traceback = traceback.format_exception(exc)
+            for line in formatted_traceback:
+                print(line)  # noqa: WPS421
+            print("-" * _WRAP_LINE_WIDTH)  # noqa: WPS421
+    else:
+        _logger.error(message, exc_info=True)

melony-1.0.1/melony/redis_broker/brokers.py

@@ -0,0 +1,70 @@
+from typing import assert_never, final, override
+from redis.asyncio.client import Redis
+from redis import Redis as SyncRedis
+
+from melony.core.publishers import IAsyncPublisher, ISyncPublisher, Publisher
+from melony.core.brokers import BaseBroker
+from melony.core.result_backends import (
+    IAsyncResultBackendSaver,
+    IResultBackend,
+    ISyncResultBackendSaver,
+)
+from melony.redis_broker.consumers import (
+    AsyncRedisConsumer,
+    SyncRedisConsumer,
+    RedisConsumer
+)
+from melony.redis_broker.publishers import AsyncRedisPublisher, SyncRedisPublisher
+
+
+@final
+class RedisBroker(BaseBroker):
+    def __init__(
+        self, 
+        redis_connection: Redis | SyncRedis,
+        result_backend: IResultBackend | None = None
+    ) -> None:
+        self._connection = redis_connection
+        self._result_backend = result_backend
+
+    @property
+    @override
+    def publisher(self) -> Publisher:
+        match self._connection:
+            case Redis():
+                return AsyncRedisPublisher(connection=self._connection)
+            case SyncRedis():
+                return SyncRedisPublisher(connection=self._connection)
+            case _:
+                assert_never(_)
+
+    @property
+    @override
+    def consumer(self) -> RedisConsumer:
+        match self._connection:
+            case Redis():
+                assert isinstance(self.publisher, IAsyncPublisher)
+                if self._result_backend:
+                    assert isinstance(
+                        self._result_backend.saver,
+                        IAsyncResultBackendSaver
+                    )
+                return AsyncRedisConsumer(
+                    publisher=self.publisher,
+                    broker=self,
+                    result_backend=self._result_backend
+                )
+            case SyncRedis():
+                assert isinstance(self.publisher, ISyncPublisher)
+                if self._result_backend:
+                    assert isinstance(
+                        self._result_backend.saver,
+                        ISyncResultBackendSaver
+                    )
+                return SyncRedisConsumer(
+                    publisher=self.publisher,
+                    broker=self,
+                    result_backend=self._result_backend
+                )
+            case _:
+                assert_never(self._connection)

melony-1.0.1/melony/redis_broker/consumers.py

@@ -0,0 +1,104 @@
+from typing import Awaitable, Final, Optional, Sequence, cast, final, override
+
+from melony.core.json_task_converter import AsyncJsonTaskConverter, SyncJsonTaskConverter
+from melony.core.brokers import BaseBroker
+from melony.core.consts import REDIS_QUEUE_NAME
+from melony.core.consumers import BaseAsyncConsumer, BaseSyncConsumer
+from melony.core.publishers import IAsyncPublisher, ISyncPublisher
+from melony.core.result_backends import IAsyncResultBackendSaver, IResultBackend, ISyncResultBackendSaver
+from melony.core.tasks import Task
+
+
+type RedisConsumer = AsyncRedisConsumer | SyncRedisConsumer
+
+
+@final
+class AsyncRedisConsumer(BaseAsyncConsumer):
+    _brpop_timeout: Final[float] = 0.01
+
+    def __init__(
+        self,
+        publisher: IAsyncPublisher,
+        broker: BaseBroker,
+        result_backend: IResultBackend | None = None
+    ) -> None:
+        super().__init__(publisher, result_backend)
+        self._broker = broker
+        self._task_converter = AsyncJsonTaskConverter()
+
+    @override
+    async def _pop_tasks(self) -> Sequence[Task]:
+        tasks: list[Task] = []
+        redis_task = await cast(
+            Awaitable[Sequence[bytes]],
+            self._connection.brpop(keys=[REDIS_QUEUE_NAME])
+        )
+        tasks.append(self._deserialize_to_task_from_redis(redis_task))
+        
+        while redis_task:
+            redis_task = await cast(
+                Awaitable[Optional[Sequence[bytes]]],
+                self._connection.brpop(
+                    keys=[REDIS_QUEUE_NAME],
+                    timeout=self._brpop_timeout
+                )
+            )
+            if redis_task:
+                tasks.append(self._deserialize_to_task_from_redis(redis_task))
+        
+        return tasks
+
+    def _deserialize_to_task_from_redis(self, redis_task: Sequence[bytes]) -> Task:
+        serialized_task_bytes = redis_task[1]
+        serialized_task = serialized_task_bytes.decode("utf-8")
+        task = self._task_converter.deserialize_task(
+            serialized_task=serialized_task,
+            broker=self._broker
+        )
+        return task
+
+
+@final
+class SyncRedisConsumer(BaseSyncConsumer):
+    _brpop_timeout: Final[float] = 0.01
+
+    def __init__(
+        self,
+        publisher: ISyncPublisher,
+        broker: BaseBroker,
+        result_backend: IResultBackend | None = None
+    ) -> None:
+        super().__init__(publisher, result_backend)
+        self._broker = broker
+        self._task_converter = SyncJsonTaskConverter()
+
+    @override
+    def _pop_tasks(self) -> Sequence[Task]:
+        tasks: list[Task] = []
+        redis_task = cast(
+            Sequence[bytes],
+            self._connection.brpop(keys=[REDIS_QUEUE_NAME])
+        )
+        tasks.append(self._deserialize_to_task_from_redis(redis_task))
+        
+        while redis_task:
+            redis_task = cast(
+                Optional[Sequence[bytes]],
+                self._connection.brpop(
+                    keys=[REDIS_QUEUE_NAME],
+                    timeout=self._brpop_timeout
+                )
+            )
+            if redis_task:
+                tasks.append(self._deserialize_to_task_from_redis(redis_task))
+        
+        return tasks
+
+    def _deserialize_to_task_from_redis(self, redis_task: Sequence[bytes]) -> Task:
+        serialized_task_bytes = redis_task[1]
+        serialized_task = serialized_task_bytes.decode("utf-8")
+        task = self._task_converter.deserialize_task(
+            serialized_task=serialized_task,
+            broker=self._broker
+        )
+        return task

melony-1.0.1/melony/redis_broker/publishers.py

@@ -0,0 +1,50 @@
+from typing import Awaitable, cast, final, override
+from redis.asyncio import Redis
+from redis import Redis as SyncRedis
+
+from melony.core.consts import REDIS_QUEUE_NAME
+from melony.core.publishers import IAsyncPublisher, ISyncPublisher
+from melony.core.tasks import Task
+from melony.core.json_task_converter import AsyncJsonTaskConverter, SyncJsonTaskConverter
+
+
+@final
+class AsyncRedisPublisher(IAsyncPublisher):
+    def __init__(self, connection: Redis) -> None:
+        self._connection = connection
+        self._task_converter = AsyncJsonTaskConverter()
+
+    @property
+    @override
+    def connection(self) -> Redis:
+        return self._connection
+
+    @override
+    async def push(self, task: Task) -> None:
+        await cast(
+            Awaitable[int], self._connection.lpush(
+                REDIS_QUEUE_NAME,
+                self._task_converter.serialize_task(task)
+            )
+        )
+
+
+@final
+class SyncRedisPublisher(ISyncPublisher):
+    def __init__(self, connection: SyncRedis) -> None:
+        self._connection = connection
+        self._task_converter = SyncJsonTaskConverter()
+
+    @property
+    @override
+    def connection(self) -> SyncRedis:
+        return self._connection
+
+    @override
+    def push(self, task: Task) -> None:
+        cast(
+            int, self._connection.lpush(
+                REDIS_QUEUE_NAME,
+                self._task_converter.serialize_task(task)
+            )
+        )

melony-1.0.1/melony/redis_broker/result_backends.py

@@ -0,0 +1,74 @@
+import asyncio
+import json
+
+from typing import Sequence, final, override
+from redis.asyncio import Redis
+from redis import Redis as SyncRedis
+
+from melony.core.consts import REDIS_RESULT_BACKEND_KEY
+from melony.core.dto import TaskResultDTO
+from melony.core.result_backends import (
+    IAsyncResultBackendSaver,
+    IResultBackend,
+    ISyncResultBackendSaver,
+    ResultBackendSaver
+)
+
+
+@final
+class _AsyncRedisResultBackendSaver(IAsyncResultBackendSaver):
+    def __init__(self, redis_connection: Redis | SyncRedis) -> None:
+        self._connection = redis_connection
+
+    @override
+    async def save_results(self, task_results: Sequence[TaskResultDTO]) -> None:
+        set_result_coroutines = []
+
+        for task_result_info in task_results:
+            task_id = task_result_info.task.task_id
+            redis_key = f"{REDIS_RESULT_BACKEND_KEY}{task_id}"
+            save_task_data = {}
+            save_task_data["result"] = task_result_info.task_result
+            save_task_data["task"] = task_result_info.task.as_dict()
+            set_result_coroutines.append(
+                self._connection.set(
+                    name=redis_key,
+                    value=json.dumps(save_task_data)
+                )
+            )
+        await asyncio.gather(*set_result_coroutines)
+
+
+@final
+class _SyncRedisResultBackendSaver(ISyncResultBackendSaver):
+    def __init__(self, redis_connection: Redis | SyncRedis) -> None:
+        self._connection = redis_connection
+
+    @override
+    def save_results(self, task_results: Sequence[TaskResultDTO]) -> None:
+        for task_result_info in task_results:
+            task_id = task_result_info.task.task_id
+            redis_key = f"{REDIS_RESULT_BACKEND_KEY}{task_id}"
+            save_task_data = {}
+            save_task_data["result"] = task_result_info.task_result
+            save_task_data["task"] = task_result_info.task.as_dict()
+            self._connection.set(
+                name=redis_key,
+                value=json.dumps(save_task_data)
+            )
+
+@final
+class RedisResultBackend(IResultBackend):
+    def __init__(self, redis_connection: Redis | SyncRedis) -> None:
+        self._connection = redis_connection
+    
+    @property
+    def saver(self) -> ResultBackendSaver:
+        match self._connection:
+            case Redis():
+                return _AsyncRedisResultBackendSaver(redis_connection=self._connection)
+            case SyncRedis():
+                return _SyncRedisResultBackendSaver(redis_connection=self._connection)
+            case _:
+                assert_never(_)
+

melony-1.0.1/melony.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: melony
+Version: 1.0.1
+Summary: Multisync task manager for python
+Home-page: https://melony-python.com/
+Author: wimble3
+Author-email: wimble@internet.ru
+License: UNKNOWN
+Project-URL: Documentation, https://melony-python.com/docs
+Keywords: task manager python melony
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+UNKNOWN
+

melony-1.0.1/melony.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+README.md
+pyproject.toml
+setup.py
+melony/__init__.py
+melony/logger.py
+melony.egg-info/PKG-INFO
+melony.egg-info/SOURCES.txt
+melony.egg-info/dependency_links.txt
+melony.egg-info/requires.txt
+melony.egg-info/top_level.txt
+melony/core/__init__.py
+melony/core/brokers.py
+melony/core/consts.py
+melony/core/consumers.py
+melony/core/dto.py
+melony/core/json_task_converter.py
+melony/core/publishers.py
+melony/core/result_backends.py
+melony/core/task_executor.py
+melony/core/task_finders.py
+melony/core/task_wrappers.py
+melony/core/tasks.py
+melony/redis_broker/__init__.py
+melony/redis_broker/brokers.py
+melony/redis_broker/consumers.py
+melony/redis_broker/publishers.py
+melony/redis_broker/result_backends.py

melony-1.0.1/melony.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

melony-1.0.1/melony.egg-info/requires.txt

@@ -0,0 +1,7 @@
+asyncio>=4.0.0
+classes>=0.4.1
+pytest-asyncio>=1.1.0
+pytest>=8.4.1
+redis>=6.4.0
+setuptools>=80.10.2
+wemake-python-styleguide>=1.3.0

melony-1.0.1/melony.egg-info/top_level.txt

@@ -0,0 +1 @@
+melony

melony-1.0.1/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "melony"
+version = "1.0.1"
+description = "multisync task manager for python"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "asyncio>=4.0.0",
+    "classes>=0.4.1",
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.1.0",
+    "redis>=6.4.0",
+    "wemake-python-styleguide>=1.3.0",
+]

melony-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

melony-1.0.1/setup.py

@@ -0,0 +1,38 @@
+from setuptools import setup, find_packages
+
+
+def readme():
+  with open("README.md", "r") as file:
+    return file.read()
+
+
+setup(
+  name="melony",
+  version="1.0.1",
+  author="wimble3",
+  author_email="wimble@internet.ru",
+  description='Multisync task manager for python',
+  long_description=readme(),
+  long_description_content_type="text/markdown",
+  url="https://melony-python.com/",
+  packages=find_packages(),
+  install_requires=[
+    "asyncio>=4.0.0",
+    "classes>=0.4.1",
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.1.0",
+    "redis>=6.4.0",
+    "setuptools>=80.10.2",
+    "wemake-python-styleguide>=1.3.0",
+  ],
+  classifiers=[
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+  ],
+  keywords='task manager python melony',
+  project_urls={
+    "Documentation": "https://melony-python.com/docs"
+  },
+  python_requires='>=3.12'
+)