avtomatika 1.0b6__py3-none-any.whl → 1.0b8__py3-none-any.whl

avtomatika/utils/webhook_sender.py

@@ -0,0 +1,96 @@
+from asyncio import CancelledError, Queue, QueueFull, create_task, sleep
+from contextlib import suppress
+from dataclasses import asdict, dataclass
+from logging import getLogger
+from typing import Any
+
+from aiohttp import ClientSession, ClientTimeout
+
+logger = getLogger(__name__)
+
+
+@dataclass
+class WebhookPayload:
+    event: str  # "job_finished", "job_failed", "job_quarantined"
+    job_id: str
+    status: str
+    result: dict[str, Any] | None = None
+    error: str | None = None
+
+
+class WebhookSender:
+    def __init__(self, session: ClientSession):
+        self.session = session
+        self.timeout = ClientTimeout(total=10)
+        self.max_retries = 3
+        self._queue: Queue[tuple[str, WebhookPayload]] = Queue(maxsize=1000)
+        self._worker_task = None
+
+    def start(self) -> None:
+        if not self._worker_task:
+            self._worker_task = create_task(self._worker())
+            logger.info("WebhookSender background worker started.")
+
+    async def stop(self) -> None:
+        if self._worker_task:
+            self._worker_task.cancel()
+            with suppress(CancelledError):
+                await self._worker_task
+            self._worker_task = None
+            logger.info("WebhookSender background worker stopped.")
+
+    async def send(self, url: str, payload: WebhookPayload) -> None:
+        """
+        Queues a webhook to be sent. Non-blocking.
+        Drops the message if the queue is full to prevent backpressure.
+        """
+        try:
+            self._queue.put_nowait((url, payload))
+        except QueueFull:
+            logger.error(
+                f"Webhook queue is full! Dropping webhook for job {payload.job_id} to {url}. "
+                "Consider increasing queue size or checking external service latency."
+            )
+
+    async def _worker(self) -> None:
+        while True:
+            try:
+                url, payload = await self._queue.get()
+                try:
+                    await self._send_single(url, payload)
+                except Exception as e:
+                    logger.exception(f"Unexpected error in webhook worker: {e}")
+                finally:
+                    self._queue.task_done()
+            except CancelledError:
+                break
+
+    async def _send_single(self, url: str, payload: WebhookPayload) -> bool:
+        """
+        Sends a webhook payload to the specified URL with retries.
+        Returns True if successful, False otherwise.
+        """
+        data = asdict(payload)
+        for attempt in range(1, self.max_retries + 1):
+            try:
+                async with self.session.post(url, json=data, timeout=self.timeout) as response:
+                    if 200 <= response.status < 300:
+                        logger.info(f"Webhook sent successfully to {url} for job {payload.job_id}")
+                        return True
+                    else:
+                        logger.warning(
+                            f"Webhook failed for job {payload.job_id} to {url}. "
+                            f"Status: {response.status}. Attempt {attempt}/{self.max_retries}"
+                        )
+            except Exception as e:
+                logger.warning(
+                    f"Error sending webhook for job {payload.job_id} to {url}: {e}. "
+                    f"Attempt {attempt}/{self.max_retries}"
+                )
+
+            # Exponential backoff
+            if attempt < self.max_retries:
+                await sleep(2**attempt)
+
+        logger.error(f"Failed to send webhook for job {payload.job_id} to {url} after {self.max_retries} attempts.")
+        return False

avtomatika/watcher.py

@@ -26,48 +26,43 @@ class Watcher:
         self._running = True
         while self._running:
             try:
-                await sleep(self.watch_interval_seconds)
-
                 # Attempt to acquire distributed lock
-                # We set TTL slightly longer than the expected execution time,
-                # but shorter than the interval if possible.
-                # Actually, a fixed TTL like 60s is fine as long as we release it.
-                if not await self.storage.acquire_lock("global_watcher_lock", self._instance_id, 60):
-                    logger.debug("Watcher lock held by another instance. Skipping check.")
-                    continue
+                # We set TTL slightly longer than the expected execution time (60s)
+                if await self.storage.acquire_lock("global_watcher_lock", self._instance_id, 60):
+                    try:
+                        logger.debug("Watcher running check for timed out jobs...")
+                        timed_out_job_ids = await self.storage.get_timed_out_jobs(limit=100)
 
-                try:
-                    logger.info("Watcher running check for timed out jobs...")
-                    timed_out_job_ids = await self.storage.get_timed_out_jobs()
+                        for job_id in timed_out_job_ids:
+                            logger.warning(f"Job {job_id} timed out. Moving to failed state.")
+                            try:
+                                # Get the latest version to avoid overwriting
+                                job_state = await self.storage.get_job_state(job_id)
+                                if job_state and job_state["status"] == "waiting_for_worker":
+                                    job_state["status"] = "failed"
+                                    job_state["error_message"] = "Worker task timed out."
+                                    await self.storage.save_job_state(job_id, job_state)
 
-                    for job_id in timed_out_job_ids:
-                        logger.warning(f"Job {job_id} timed out. Moving to failed state.")
-                        try:
-                            # Get the latest version to avoid overwriting
-                            job_state = await self.storage.get_job_state(job_id)
-                            if job_state and job_state["status"] == "waiting_for_worker":
-                                job_state["status"] = "failed"
-                                job_state["error_message"] = "Worker task timed out."
-                                await self.storage.save_job_state(job_id, job_state)
+                                    # Increment the metric
+                                    from . import metrics
 
-                                # Increment the metric
-                                from . import metrics
-
-                                metrics.jobs_failed_total.inc(
-                                    {
-                                        metrics.LABEL_BLUEPRINT: job_state.get(
-                                            "blueprint_name",
-                                            "unknown",
-                                        ),
-                                    },
+                                    metrics.jobs_failed_total.inc(
+                                        {
+                                            metrics.LABEL_BLUEPRINT: job_state.get(
+                                                "blueprint_name",
+                                                "unknown",
+                                            ),
+                                        },
+                                    )
+                            except Exception:
+                                logger.exception(
+                                    f"Failed to update state for timed out job {job_id}",
                                 )
-                        except Exception:
-                            logger.exception(
-                                f"Failed to update state for timed out job {job_id}",
-                            )
-                finally:
-                    # Always release the lock so we (or others) can run next time
-                    await self.storage.release_lock("global_watcher_lock", self._instance_id)
+                    finally:
+                        # Always release the lock so we (or others) can run next time
+                        await self.storage.release_lock("global_watcher_lock", self._instance_id)
+                else:
+                    logger.debug("Watcher lock held by another instance. Skipping check.")
 
             except CancelledError:
                 logger.info("Watcher received cancellation request.")
@@ -75,7 +70,8 @@ class Watcher:
             except Exception:
                 logger.exception("Error in Watcher main loop.")
 
-        logger.info("Watcher stopped.")
+            # Sleep at the end of iteration
+            await sleep(self.watch_interval_seconds)
 
     def stop(self):
         """Stops the watcher."""

avtomatika/ws_manager.py

@@ -1,5 +1,6 @@
 from asyncio import Lock
 from logging import getLogger
+from typing import Any
 
 from aiohttp import web
 
@@ -9,11 +10,11 @@ logger = getLogger(__name__)
 class WebSocketManager:
     """Manages active WebSocket connections from workers."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._connections: dict[str, web.WebSocketResponse] = {}
         self._lock = Lock()
 
-    async def register(self, worker_id: str, ws: web.WebSocketResponse):
+    async def register(self, worker_id: str, ws: web.WebSocketResponse) -> None:
         """Registers a new WebSocket connection for a worker."""
         async with self._lock:
             if worker_id in self._connections:
@@ -22,14 +23,14 @@ class WebSocketManager:
             self._connections[worker_id] = ws
             logger.info(f"WebSocket connection registered for worker {worker_id}.")
 
-    async def unregister(self, worker_id: str):
+    async def unregister(self, worker_id: str) -> None:
         """Unregisters a WebSocket connection."""
         async with self._lock:
             if worker_id in self._connections:
                 del self._connections[worker_id]
                 logger.info(f"WebSocket connection for worker {worker_id} unregistered.")
 
-    async def send_command(self, worker_id: str, command: dict):
+    async def send_command(self, worker_id: str, command: dict[str, Any]) -> bool:
         """Sends a JSON command to a specific worker."""
         async with self._lock:
             connection = self._connections.get(worker_id)
@@ -46,7 +47,7 @@ class WebSocketManager:
                 return False
 
     @staticmethod
-    async def handle_message(worker_id: str, message: dict):
+    async def handle_message(worker_id: str, message: dict[str, Any]) -> None:
         """Handles an incoming message from a worker."""
         event_type = message.get("event")
         if event_type == "progress_update":
@@ -59,7 +60,7 @@ class WebSocketManager:
         else:
             logger.debug(f"Received unhandled event from worker {worker_id}: {event_type}")
 
-    async def close_all(self):
+    async def close_all(self) -> None:
         """Closes all active WebSocket connections."""
         async with self._lock:
             logger.info(f"Closing {len(self._connections)} active WebSocket connections...")

{avtomatika-1.0b6.dist-info → avtomatika-1.0b8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avtomatika
-Version: 1.0b6
+Version: 1.0b8
 Summary: A state-machine based orchestrator for long-running AI and other jobs.
 Project-URL: Homepage, https://github.com/avtomatika-ai/avtomatika
 Project-URL: Bug Tracker, https://github.com/avtomatika-ai/avtomatika/issues
@@ -12,7 +12,6 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp~=3.12
-Requires-Dist: aiocache~=0.12
 Requires-Dist: python-json-logger~=4.0
 Requires-Dist: graphviz~=0.21
 Requires-Dist: zstandard~=0.24
@@ -21,6 +20,9 @@ Requires-Dist: msgpack~=1.1
 Requires-Dist: orjson~=3.11
 Provides-Extra: redis
 Requires-Dist: redis~=7.1; extra == "redis"
+Provides-Extra: s3
+Requires-Dist: obstore>=0.2; extra == "s3"
+Requires-Dist: aiofiles~=23.2; extra == "s3"
 Provides-Extra: history
 Requires-Dist: aiosqlite~=0.22; extra == "history"
 Requires-Dist: asyncpg~=0.30; extra == "history"
@@ -38,10 +40,13 @@ Requires-Dist: pytest-mock~=3.14; extra == "test"
 Requires-Dist: aioresponses~=0.7; extra == "test"
 Requires-Dist: backports.zstd~=1.2; extra == "test"
 Requires-Dist: opentelemetry-instrumentation-aiohttp-client; extra == "test"
+Requires-Dist: obstore>=0.2; extra == "test"
+Requires-Dist: aiofiles~=23.2; extra == "test"
 Provides-Extra: all
 Requires-Dist: avtomatika[redis]; extra == "all"
 Requires-Dist: avtomatika[history]; extra == "all"
 Requires-Dist: avtomatika[telemetry]; extra == "all"
+Requires-Dist: avtomatika[s3]; extra == "all"
 Dynamic: license-file
 
 # Avtomatika Orchestrator
@@ -61,6 +66,8 @@ This document serves as a comprehensive guide for developers looking to build pi
   - [Parallel Execution and Aggregation (Fan-out/Fan-in)](#parallel-execution-and-aggregation-fan-outfan-in)
   - [Dependency Injection (DataStore)](#dependency-injection-datastore)
   - [Native Scheduler](#native-scheduler)
+  - [S3 Payload Offloading](#s3-payload-offloading)
+  - [Webhook Notifications](#webhook-notifications)
 - [Production Configuration](#production-configuration)
   - [Fault Tolerance](#fault-tolerance)
   - [Storage Backend](#storage-backend)
@@ -107,6 +114,11 @@ Avtomatika is part of a larger ecosystem:
     pip install "avtomatika[telemetry]"
     ```
 
+*   **Install with S3 support (Payload Offloading):**
+    ```bash
+    pip install "avtomatika[s3]"
+    ```
+
 *   **Install all dependencies, including for testing:**
     ```bash
     pip install "avtomatika[all,test]"
@@ -157,7 +169,13 @@ async def end_handler(context):
 engine = OrchestratorEngine(storage, config)
 engine.register_blueprint(my_blueprint)
 
-# 4. Define the main entrypoint to run the server
+# 4. Accessing Components (Optional)
+# You can access the internal aiohttp app and core components using AppKeys
+# from avtomatika.app_keys import ENGINE_KEY, DISPATCHER_KEY
+# app = engine.app
+# dispatcher = app[DISPATCHER_KEY]
+
+# 5. Define the main entrypoint to run the server
 async def main():
     await engine.start()
     
@@ -244,6 +262,19 @@ async def publish_handler_old_style(context):
     print(f"Job {context.job_id}: Publishing video at {output_path} ({duration}s).")
     context.actions.transition_to("complete")
 ```
+## Key Concepts: JobContext and Actions
+
+### High Performance Architecture
+
+Avtomatika is engineered for high-load environments with thousands of concurrent workers.
+
+*   **O(1) Dispatcher**: Uses advanced Redis Set intersections to find suitable workers instantly, regardless of the cluster size. No O(N) scanning.
+*   **Non-Blocking I/O**:
+    *   **Webhooks**: Sent via a bounded background queue to prevent backpressure.
+    *   **History Logging**: Writes to SQL databases are buffered and asynchronous, ensuring the main execution loop never blocks.
+    *   **Redis Streams**: Uses blocking reads to eliminate busy-waiting and reduce CPU usage.
+*   **Memory Safety**: S3 file transfers use streaming to handle multi-gigabyte files with constant, low RAM usage.
+
 ## Blueprint Cookbook: Key Features
 
 ### 1. Conditional Transitions (`.when()`)
@@ -355,6 +386,63 @@ blueprint = "backup_flow"
 daily_at = "02:00"
 ```
 
+### 6. Webhook Notifications
+
+The orchestrator can send asynchronous notifications to an external system when a job completes, fails, or is quarantined. This eliminates the need for clients to constantly poll the API for status updates.
+
+### 7. S3 Payload Offloading
+
+Orchestrator provides first-class support for handling large files via S3-compatible storage, powered by the high-performance `obstore` library (Rust bindings).
+
+*   **Memory Safe (Streaming)**: Uses streaming for uploads and downloads, allowing processing of files larger than available RAM without OOM errors.
+*   **Managed Mode**: The Orchestrator manages file lifecycle (automatic cleanup of S3 objects and local temporary files on job completion).
+*   **Dependency Injection**: Use the `task_files` argument in your handlers to easily read/write data.
+*   **Directory Support**: Supports recursive download and upload of entire directories.
+
+```python
+@bp.handler_for("process_data")
+async def process_data(task_files, actions):
+    # Streaming download of a large file
+    local_path = await task_files.download("large_dataset.csv")
+    
+    # ... process data ...
+    
+    # Upload results
+    await task_files.write_json("results.json", {"status": "done"})
+    
+    actions.transition_to("finished")
+```
+
+## Production Configuration
+*   **Events:**
+    *   `job_finished`: The job reached a final success state.
+    *   `job_failed`: The job failed (e.g., due to an error or invalid input).
+    *   `job_quarantined`: The job was moved to quarantine after repeated failures.
+
+**Example Request:**
+```json
+POST /api/v1/jobs/my_flow
+{
+    "initial_data": {
+        "video_url": "..."
+    },
+    "webhook_url": "https://my-app.com/webhooks/avtomatika"
+}
+```
+
+**Example Webhook Payload:**
+```json
+{
+    "event": "job_finished",
+    "job_id": "123e4567-e89b-12d3-a456-426614174000",
+    "status": "finished",
+    "result": {
+        "output_path": "/videos/result.mp4"
+    },
+    "error": null
+}
+```
+
 ## Production Configuration
 
 The orchestrator's behavior can be configured through environment variables. Additionally, any configuration parameter loaded from environment variables can be programmatically overridden in your application code after the `Config` object has been initialized. This provides flexibility for different deployment and testing scenarios.

avtomatika-1.0b8.dist-info/RECORD

@@ -0,0 +1,46 @@
+avtomatika/__init__.py,sha256=D5r3L-H06uxsY_wgfh7u9YR29QvZMer1BlvzjW9Umfo,701
+avtomatika/api.html,sha256=RLx-D1uFCSAXIf_2WgFlSTWrWPcmonNYM-9oNanKXBg,32835
+avtomatika/app_keys.py,sha256=XL9Q1Ef5JYa_JG8LM3jzb3cOQjnKaM6ypwqXWnUKeDU,1212
+avtomatika/blueprint.py,sha256=AJ8hZkzvqkdu9aPmlJeFzuSj57L6Xm41KS9kBMGB4Vg,11827
+avtomatika/client_config_loader.py,sha256=zVVHZlxSqZUaNpZ4zoU0T1CFYXdxy-3vKSmPcaFuHSY,2772
+avtomatika/compression.py,sha256=bhA1kw4YrCR3I3kdquZSY0fAzCrRrjtz55uepzLUDKI,2498
+avtomatika/config.py,sha256=zqaZrt44Zd_ppvWPDkSth1nJydhAsK0jQLDo0QIW77A,3103
+avtomatika/constants.py,sha256=WL58Nh-EY6baM9Ur_tR9merwPRGb41_klUG2V-yUUaA,963
+avtomatika/context.py,sha256=T6Ux4Fb1DwWRGTpMNeukM51MQDQbGk2HS6Cwpc0dc1s,4248
+avtomatika/data_types.py,sha256=nm9pLhLLx8fngjvAE8d3nQZkD8Y3Q28RHch9kjYAG2Y,1447
+avtomatika/datastore.py,sha256=gJjhZ5kxjF8pmbbPQb_qu3HPUpfy2c6T75KZ-smb_zg,545
+avtomatika/dispatcher.py,sha256=CKqniknJZe7gjY7QmGlODJc5X8B6qWjtr2UxRivUbuY,8603
+avtomatika/engine.py,sha256=VUw5s65Q403a1JgkRtF1KeSiVx1W6MFmukxZpYN-f00,16175
+avtomatika/executor.py,sha256=K7RGGxWz_4n6q0m8tW0oNtUJm90b-4O2U9lTB_yLX-k,24461
+avtomatika/health_checker.py,sha256=jXYSH4BPeZ4LCxSZV4uXM4BZhGJYgpoAOWQXE8yojLo,2078
+avtomatika/logging_config.py,sha256=Zb6f9Nri9WVWhlpuBg6Lpi5SWRLGIUmS8Dc3xD1Gg0g,2993
+avtomatika/metrics.py,sha256=tiksK1fFSOMlz8zFu6GT19JTduvxMTNlLu0QFrTHoQI,1866
+avtomatika/py.typed,sha256=CT_L7gw2MLcQY-X0vs-xB5Vr0wzvGo7GuQYPI_qwJE8,65
+avtomatika/quota.py,sha256=DNcaL6k0J1REeP8sVqbY9FprY_3BSr2SxM2Vf4mEqdw,1612
+avtomatika/ratelimit.py,sha256=hFGW5oN9G6_W_jnHmopXW8bRjjzlvanY19MLghsNLE8,1306
+avtomatika/reputation.py,sha256=pK-x9FrPN2Oc2gtPa1AZJHlhvkd7xlRe4orxM2auJJc,3979
+avtomatika/s3.py,sha256=d-zyqdS0dV6K_92BbOH4Lo0Um0AvrMxfSFoD5QFPBSo,11941
+avtomatika/scheduler.py,sha256=F5Kv5Rx34nDd0mE5jxjwpjRg8duDZBEr91N5Y6CNR24,4231
+avtomatika/scheduler_config_loader.py,sha256=F6mLM8yPRgG4bMHV_WnXX7UOrXD8fCXJT30bbEuQ2mk,1311
+avtomatika/security.py,sha256=kkU68YmLWq1ClMUdEW98pS9WsEwHinHoZcdMoPm63Uk,4417
+avtomatika/telemetry.py,sha256=ZBt1_xJ36PzDSz-zdCXeNp58NiezUgbqvMctTG25PT0,2352
+avtomatika/watcher.py,sha256=-oqyUKq4WYtFYe0PjfDkAjjTUxpyN79JTnOzwlg-Z84,3467
+avtomatika/worker_config_loader.py,sha256=n0j8gfuJDacWONr8744RsHTCWpc_1ZTRMC-rJZh6P6A,2249
+avtomatika/ws_manager.py,sha256=fjIGWZF_L5j5QEpTdNT2Qz4N5ut9pjKlgEKI0sY2GOc,3148
+avtomatika/api/handlers.py,sha256=MO6QkbT001jj4latUXGT0hGOmQf_6TkRkmwx19OcXeQ,22176
+avtomatika/api/routes.py,sha256=vSwj2jJlmftZrjrctt-mNYLF23CfCtlUfaMoZzNOqCk,4895
+avtomatika/history/base.py,sha256=RsCvCkHK1teHjXSk9ZHVEtpQlIjz8kWsfKYHVnapf6c,3848
+avtomatika/history/noop.py,sha256=hLzt0RblsrKUtoyQNauOni6jCi-IYCWEPsiR0vh7tho,1226
+avtomatika/history/postgres.py,sha256=T0XpDurnh48pPI-2JhB285GdNIexNkCSu8ExhLJzcxc,9538
+avtomatika/history/sqlite.py,sha256=txWax9RVzBQzIZuU-SjHnEXEzBmGzIjqzoVsK2oyiAQ,9252
+avtomatika/storage/__init__.py,sha256=mGRj_40dWZ7R7uYbqC6gCsUWCKHAbZz4ZVIhYg5dT_E,262
+avtomatika/storage/base.py,sha256=l6ppbvbIshb5cD0yByDAeCSePBWp05iuaovbi4gaWww,12939
+avtomatika/storage/memory.py,sha256=cZRVHqXRn3Gm06jJirBOk2IgB-ocqaJQSmzUEsCmK-M,14009
+avtomatika/storage/redis.py,sha256=WrUbDq1wC9fpFjMM0IqkbYAvmwm9-s3DmEFo8sO18FA,18664
+avtomatika/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+avtomatika/utils/webhook_sender.py,sha256=4Ud2Tz18yV4kzfGQyDO2by8s2EIEwHkv1vtIUis9kVQ,3606
+avtomatika-1.0b8.dist-info/licenses/LICENSE,sha256=tqCjw9Y1vbU-hLcWi__7wQstLbt2T1XWPdbQYqCxuWY,1072
+avtomatika-1.0b8.dist-info/METADATA,sha256=AV7TG3pNVxvHyj7eyS5OTo7BXrBigb4mFCfJvtZqzTM,26382
+avtomatika-1.0b8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+avtomatika-1.0b8.dist-info/top_level.txt,sha256=gLDWhA_wxHj0I6fG5X8vw9fE0HSN4hTE2dEJzeVS2x8,11
+avtomatika-1.0b8.dist-info/RECORD,,

avtomatika-1.0b6.dist-info/RECORD

@@ -1,40 +0,0 @@
-avtomatika/__init__.py,sha256=D5r3L-H06uxsY_wgfh7u9YR29QvZMer1BlvzjW9Umfo,701
-avtomatika/api.html,sha256=RLx-D1uFCSAXIf_2WgFlSTWrWPcmonNYM-9oNanKXBg,32835
-avtomatika/blueprint.py,sha256=jU1Un9yiIUbZ9I7k20XyAhnMbXyrnkC0AakMX3GbK6k,9207
-avtomatika/client_config_loader.py,sha256=zVVHZlxSqZUaNpZ4zoU0T1CFYXdxy-3vKSmPcaFuHSY,2772
-avtomatika/compression.py,sha256=bhA1kw4YrCR3I3kdquZSY0fAzCrRrjtz55uepzLUDKI,2498
-avtomatika/config.py,sha256=Tc-vpaQS11i_JTa1pQjGuQD3R5Kj9sIf6gGJGjItBBo,2487
-avtomatika/constants.py,sha256=WL58Nh-EY6baM9Ur_tR9merwPRGb41_klUG2V-yUUaA,963
-avtomatika/context.py,sha256=MT_RMMxSCAVEhlo5HUQdQ1uaR86D9d4s_3nrd6O5xAg,4241
-avtomatika/data_types.py,sha256=VWWbTcJaQt43JaD09qZL1spwNdzCR9vPXVthlM133gM,1362
-avtomatika/datastore.py,sha256=gJjhZ5kxjF8pmbbPQb_qu3HPUpfy2c6T75KZ-smb_zg,545
-avtomatika/dispatcher.py,sha256=Tsye9zOcLN2c7O0AalbX9Il5l3XdT64UDV7iQKiLIJE,9627
-avtomatika/engine.py,sha256=fSCalpR3-j-ATmDE5XMYjz1PSubVcrbeMFWGX_NRI8g,41883
-avtomatika/executor.py,sha256=-SKqLs-DVtMw5P7bZInK57f0M4zRFoVFr1fU5MUrtiY,22543
-avtomatika/health_checker.py,sha256=WXwvRJ-3cZC2Udc_ogsyIQp7VzcvJjq_IaqzkTdE0TE,1265
-avtomatika/logging_config.py,sha256=Zb6f9Nri9WVWhlpuBg6Lpi5SWRLGIUmS8Dc3xD1Gg0g,2993
-avtomatika/metrics.py,sha256=7XDhr_xMJ9JpElpZmBG7R0ml7AMdAp9UYp_W-i7tyLg,1858
-avtomatika/py.typed,sha256=CT_L7gw2MLcQY-X0vs-xB5Vr0wzvGo7GuQYPI_qwJE8,65
-avtomatika/quota.py,sha256=DNcaL6k0J1REeP8sVqbY9FprY_3BSr2SxM2Vf4mEqdw,1612
-avtomatika/ratelimit.py,sha256=hFGW5oN9G6_W_jnHmopXW8bRjjzlvanY19MLghsNLE8,1306
-avtomatika/reputation.py,sha256=IHcaIAILWZftPPmXj5En28OSDNK7U8ivQ-w30zIF8fk,3748
-avtomatika/scheduler.py,sha256=D-qpoGSA_Jqq1R7GlJNma9tssCujNwkOnWcRbbCHTnk,4138
-avtomatika/scheduler_config_loader.py,sha256=F6mLM8yPRgG4bMHV_WnXX7UOrXD8fCXJT30bbEuQ2mk,1311
-avtomatika/security.py,sha256=kkU68YmLWq1ClMUdEW98pS9WsEwHinHoZcdMoPm63Uk,4417
-avtomatika/telemetry.py,sha256=ZBt1_xJ36PzDSz-zdCXeNp58NiezUgbqvMctTG25PT0,2352
-avtomatika/watcher.py,sha256=IHaqSqp3XSGXjRY-LEeTG9BJpq2nqJSnmjY_Vdvk3jo,3493
-avtomatika/worker_config_loader.py,sha256=n0j8gfuJDacWONr8744RsHTCWpc_1ZTRMC-rJZh6P6A,2249
-avtomatika/ws_manager.py,sha256=pi5xe0ivsCjRZw08ri5N-gAChMH2I2YPLpl3E2tP89k,3057
-avtomatika/history/base.py,sha256=Gfw0Gb4Mt9wQrMlYLugZwey_6-cDej5OUctiMTCWg7Q,1668
-avtomatika/history/noop.py,sha256=ETVtPiTfkaMpzhGD8c0_4Iu6pWD89dnPrrRrSIjmc8s,970
-avtomatika/history/postgres.py,sha256=vtW4LMW7Vli5MjcGYY3ez667-C8Cq3I7kIHrcEgSYps,9409
-avtomatika/history/sqlite.py,sha256=Blc9ckvzoDaMRStXyfJOzMAdU_t2JcwtQtVdPgnr6s0,9131
-avtomatika/storage/__init__.py,sha256=mGRj_40dWZ7R7uYbqC6gCsUWCKHAbZz4ZVIhYg5dT_E,262
-avtomatika/storage/base.py,sha256=hW7XFhe6CQDP69q5NPSkUzEInIFxDR1-AyRPZNPEDEc,11424
-avtomatika/storage/memory.py,sha256=Px_ISqZz5Nhl5wLvGpMqY21-eKaLfkzgof7jquCmHaM,12234
-avtomatika/storage/redis.py,sha256=opOhqBL_uCsNXcMD_W_tJU-8wzDUSjBJWEsXrwP2_YM,21035
-avtomatika-1.0b6.dist-info/licenses/LICENSE,sha256=tqCjw9Y1vbU-hLcWi__7wQstLbt2T1XWPdbQYqCxuWY,1072
-avtomatika-1.0b6.dist-info/METADATA,sha256=kBfLgOgvd1e06JZ_l6TJwsyAHi81jLFnqZ03QoZbISA,22986
-avtomatika-1.0b6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-avtomatika-1.0b6.dist-info/top_level.txt,sha256=gLDWhA_wxHj0I6fG5X8vw9fE0HSN4hTE2dEJzeVS2x8,11
-avtomatika-1.0b6.dist-info/RECORD,,