Перенес workflow

src/app_runtime/queue/in_memory.py

@@ -1,43 +1,38 @@
 from __future__ import annotations
 
 from queue import Empty, Queue
+from typing import Generic, TypeVar
 
-from app_runtime.contracts.queue import TaskQueue
-from app_runtime.contracts.tasks import Task
+T = TypeVar("T")
 
 
-class InMemoryTaskQueue(TaskQueue):
+class InMemoryTaskQueue(Generic[T]):
     def __init__(self) -> None:
-        self._queue: Queue[Task] = Queue()
-        self._published = 0
-        self._acked = 0
-        self._nacked = 0
+        self._queue: Queue[T] = Queue()
+        self._put_count = 0
+        self._get_count = 0
 
-    def publish(self, task: Task) -> None:
-        self._published += 1
-        self._queue.put(task)
+    def put(self, item: T) -> None:
+        self._put_count += 1
+        self._queue.put(item)
 
-    def consume(self, timeout: float = 0.1) -> Task | None:
+    def get(self, timeout: float = 0.1) -> T | None:
         try:
-            return self._queue.get(timeout=timeout)
+            item = self._queue.get(timeout=timeout)
         except Empty:
             return None
+        self._get_count += 1
+        return item
 
-    def ack(self, task: Task) -> None:
-        del task
-        self._acked += 1
+    def task_done(self) -> None:
         self._queue.task_done()
 
-    def nack(self, task: Task, retry_delay: float | None = None) -> None:
-        del retry_delay
-        self._nacked += 1
-        self._queue.put(task)
-        self._queue.task_done()
+    def qsize(self) -> int:
+        return self._queue.qsize()
 
     def stats(self) -> dict[str, int]:
         return {
-            "published": self._published,
-            "acked": self._acked,
-            "nacked": self._nacked,
+            "put": self._put_count,
+            "got": self._get_count,
             "queued": self._queue.qsize(),
         }