MeUtils 2025.3.14.8.43.3__py3-none-any.whl → 2025.3.19.19.13.35__py3-none-any.whl

meutils/other/aiomultiprocess/scheduler.py

@@ -1,83 +0,0 @@
-# Copyright 2019 John Reese
-# Licensed under the MIT license
-
-import itertools
-from abc import ABC, abstractmethod
-from typing import Any, Awaitable, Callable, Dict, Iterator, List, Sequence
-
-from .types import Queue, QueueID, R, TaskID
-
-
-class Scheduler(ABC):
-    @abstractmethod
-    def register_queue(self, tx: Queue) -> QueueID:
-        """
-        Notify the scheduler when the pool creates a new transmit queue.
-        """
-
-    @abstractmethod
-    def register_process(self, qid: QueueID) -> None:
-        """
-        Notify the scheduler when a process is assigned to a queue.
-
-        This should be used for determining weights for the scheduler.
-        It will only be called during initial process mapping.
-        """
-
-    @abstractmethod
-    def schedule_task(
-        self,
-        task_id: TaskID,
-        func: Callable[..., Awaitable[R]],
-        args: Sequence[Any],
-        kwargs: Dict[str, Any],
-    ) -> QueueID:
-        """
-        Given a task, return a queue ID that it should be sent to.
-
-        `func`, `args` and `kwargs` are just the exact same arguments
-        that `queue_work` takes, not every scheduler would be benefit from this.
-        Example that they would be useful, highly customized schedule may want
-        to schedule according to function/arguments weights.
-        """
-
-    @abstractmethod
-    def complete_task(self, task_id: TaskID) -> None:
-        """
-        Notify the scheduler that a task has been completed.
-        """
-
-
-class RoundRobin(Scheduler):
-    """
-    The default scheduling algorithm that assigns tasks to queues in round robin order.
-
-    When multiple processes are assigned to the same queue, this will weight tasks
-    accordingly. For example, 12 processes over 8 queues should result in four queues
-    receiving double the number tasks compared to the other eight.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.qids: List[QueueID] = []
-        self.next_id = itertools.count()
-        self.cycler: Iterator[QueueID] = itertools.cycle([])
-
-    def register_queue(self, tx: Queue) -> QueueID:
-        return QueueID(next(self.next_id))
-
-    def register_process(self, qid: QueueID) -> None:
-        self.qids.append(qid)
-        self.cycler = itertools.cycle(self.qids)
-
-    def schedule_task(
-        self,
-        _task_id: TaskID,
-        _func: Callable[..., Awaitable[R]],
-        _args: Sequence[Any],
-        _kwargs: Dict[str, Any],
-    ) -> QueueID:
-        return next(self.cycler)
-
-    def complete_task(self, _task_id: TaskID) -> None:
-        pass

meutils/other/aiomultiprocess/types.py

@@ -1,48 +0,0 @@
-# Copyright 2018 John Reese
-# Licensed under the MIT license
-
-import multiprocessing
-from asyncio import BaseEventLoop
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    NamedTuple,
-    NewType,
-    Optional,
-    Sequence,
-    Tuple,
-    TypeVar,
-)
-
-T = TypeVar("T")
-R = TypeVar("R")
-
-Context = multiprocessing.context.BaseContext
-Queue = multiprocessing.Queue
-
-TaskID = NewType("TaskID", int)
-QueueID = NewType("QueueID", int)
-
-TracebackStr = str
-
-LoopInitializer = Callable[..., BaseEventLoop]
-PoolTask = Optional[Tuple[TaskID, Callable[..., R], Sequence[T], Dict[str, T]]]
-PoolResult = Tuple[TaskID, Optional[R], Optional[TracebackStr]]
-
-
-class Unit(NamedTuple):
-    """Container for what to call on the child process."""
-
-    target: Callable
-    args: Sequence[Any]
-    kwargs: Dict[str, Any]
-    namespace: Any
-    initializer: Optional[Callable] = None
-    initargs: Sequence[Any] = ()
-    loop_initializer: Optional[LoopInitializer] = None
-    runner: Optional[Callable] = None
-
-
-class ProxyException(Exception):
-    pass