avtomatika 1.0b5__py3-none-any.whl → 1.0b7__py3-none-any.whl

avtomatika/scheduler_config_loader.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from tomllib import load
+from typing import Any
+
+
+@dataclass
+class ScheduledJobConfig:
+    name: str
+    blueprint: str
+    input_data: dict[str, Any]
+    interval_seconds: int | None = None
+    daily_at: str | None = None
+    weekly_days: list[str] | None = None
+    monthly_dates: list[int] | None = None
+    time: str | None = None
+
+
+def load_schedules_from_file(file_path: str) -> list[ScheduledJobConfig]:
+    """Loads scheduled job configurations from a TOML file."""
+    with open(file_path, "rb") as f:
+        data = load(f)
+
+    schedules = []
+    for name, config in data.items():
+        # Skip sections that might be metadata (though TOML structure usually implies all top-level keys are jobs)
+        if not isinstance(config, dict):
+            continue
+
+        schedules.append(
+            ScheduledJobConfig(
+                name=name,
+                blueprint=config.get("blueprint"),
+                input_data=config.get("input_data", {}),
+                interval_seconds=config.get("interval_seconds"),
+                daily_at=config.get("daily_at"),
+                weekly_days=config.get("weekly_days"),
+                monthly_dates=config.get("monthly_dates"),
+                time=config.get("time"),
+            )
+        )
+    return schedules

avtomatika/security.py

@@ -4,11 +4,9 @@ from typing import Any, Awaitable, Callable
 from aiohttp import web
 
 from .config import Config
+from .constants import AUTH_HEADER_CLIENT, AUTH_HEADER_WORKER
 from .storage.base import StorageBackend
 
-AUTH_HEADER_AVTOMATIKA = "X-Avtomatika-Token"
-AUTH_HEADER_WORKER = "X-Worker-Token"
-
 Handler = Callable[[web.Request], Awaitable[web.Response]]
 
 
@@ -21,10 +19,10 @@ def client_auth_middleware_factory(
 
     @web.middleware
     async def middleware(request: web.Request, handler: Handler) -> web.Response:
-        token = request.headers.get(AUTH_HEADER_AVTOMATIKA)
+        token = request.headers.get(AUTH_HEADER_CLIENT)
         if not token:
             return web.json_response(
-                {"error": "Missing X-Avtomatika-Token header"},
+                {"error": f"Missing {AUTH_HEADER_CLIENT} header"},
                 status=401,
             )
 

avtomatika/storage/base.py

@@ -269,13 +269,27 @@ class StorageBackend(ABC):
         """Completely clears the storage. Used mainly for tests."""
         raise NotImplementedError
 
-    @abstractmethod
     async def get_active_worker_count(self) -> int:
-        """Get the current number of active (registered) workers.
-        Used for metrics.
+        """Returns the number of currently active workers."""
+        raise NotImplementedError
+
+    async def set_nx_ttl(self, key: str, value: str, ttl: int) -> bool:
+        """
+        Atomically sets key to value if it does not exist.
+        Sets a TTL (in seconds) on the key.
+        Returns True if set, False if already exists.
+        Critical for distributed locking.
         """
         raise NotImplementedError
 
+    async def get_str(self, key: str) -> str | None:
+        """Gets a simple string value from storage."""
+        raise NotImplementedError
+
+    async def set_str(self, key: str, value: str, ttl: int | None = None) -> None:
+        """Sets a simple string value in storage with optional TTL."""
+        raise NotImplementedError
+
     @abstractmethod
     async def acquire_lock(self, key: str, holder_id: str, ttl: int) -> bool:
         """

avtomatika/storage/memory.py

@@ -33,6 +33,20 @@ class MemoryStorage(StorageBackend):
         async with self._lock:
             return self._jobs.get(job_id)
 
+    async def _clean_expired(self) -> None:
+        """Helper to remove expired keys."""
+        now = monotonic()
+
+        expired_generic = [k for k, t in self._generic_key_ttls.items() if t < now]
+        for k in expired_generic:
+            self._generic_key_ttls.pop(k, None)
+            self._generic_keys.pop(k, None)
+
+        expired_workers = [k for k, t in self._worker_ttls.items() if t < now]
+        for k in expired_workers:
+            self._worker_ttls.pop(k, None)
+            self._workers.pop(k, None)
+
     async def save_job_state(self, job_id: str, state: dict[str, Any]) -> None:
         async with self._lock:
             self._jobs[job_id] = state
@@ -88,8 +102,13 @@ class MemoryStorage(StorageBackend):
             queue = self._worker_task_queues[worker_id]
 
         try:
-            _, task_payload = await wait_for(queue.get(), timeout=timeout)
-            return task_payload
+            # Type ignore because PriorityQueue.get() return type is generic
+            item = await wait_for(queue.get(), timeout=timeout)  # type: ignore
+            _, task_payload = item
+            # Explicit cast for mypy
+            if isinstance(task_payload, dict):
+                return task_payload
+            return None  # Should not happen if data integrity is kept
         except AsyncTimeoutError:
             return None
 
@@ -127,7 +146,7 @@ class MemoryStorage(StorageBackend):
     async def get_available_workers(self) -> list[dict[str, Any]]:
         async with self._lock:
             now = monotonic()
-            active_workers = []
+            active_workers: list[dict[str, Any]] = []
             active_workers.extend(
                 worker_info
                 for worker_id, worker_info in self._workers.items()
@@ -188,7 +207,7 @@ class MemoryStorage(StorageBackend):
 
             self._generic_keys[key] += 1
             self._generic_key_ttls[key] = now + ttl
-            return self._generic_keys[key]
+            return int(self._generic_keys[key])
 
     async def save_client_config(self, token: str, config: dict[str, Any]) -> None:
         async with self._lock:
@@ -209,7 +228,7 @@ class MemoryStorage(StorageBackend):
                 return True
             return False
 
-    async def flush_all(self):
+    async def flush_all(self) -> None:
         """
         Resets all in-memory storage containers to their initial empty state.
         This is a destructive operation intended for use in tests to ensure
@@ -238,9 +257,32 @@ class MemoryStorage(StorageBackend):
 
     async def get_active_worker_count(self) -> int:
         async with self._lock:
-            now = monotonic()
-            worker_ids = list(self._workers.keys())
-            return sum(self._worker_ttls.get(worker_id, 0) > now for worker_id in worker_ids)
+            await self._clean_expired()
+            return len(self._workers)
+
+    async def set_nx_ttl(self, key: str, value: str, ttl: int) -> bool:
+        async with self._lock:
+            await self._clean_expired()
+            if key in self._generic_keys:
+                return False
+
+            self._generic_keys[key] = value
+            self._generic_key_ttls[key] = monotonic() + ttl
+            return True
+
+    async def get_str(self, key: str) -> str | None:
+        async with self._lock:
+            await self._clean_expired()
+            val = self._generic_keys.get(key)
+            return str(val) if val is not None else None
+
+    async def set_str(self, key: str, value: str, ttl: int | None = None) -> None:
+        async with self._lock:
+            self._generic_keys[key] = value
+            if ttl:
+                self._generic_key_ttls[key] = monotonic() + ttl
+            else:
+                self._generic_key_ttls.pop(key, None)
 
     async def get_worker_info(self, worker_id: str) -> dict[str, Any] | None:
         async with self._lock:

avtomatika/storage/redis.py

@@ -446,6 +446,23 @@ class RedisStorage(StorageBackend):
             count += 1
         return count
 
+    async def set_nx_ttl(self, key: str, value: str, ttl: int) -> bool:
+        """
+        Uses Redis SET command with NX (Not Exists) and EX (Expire) options.
+        """
+        # redis.set returns True if set, None if not set (when nx=True)
+        result = await self._redis.set(key, value, nx=True, ex=ttl)
+        return bool(result)
+
+    async def get_str(self, key: str) -> str | None:
+        val = await self._redis.get(key)
+        if val is None:
+            return None
+        return val.decode("utf-8") if isinstance(val, bytes) else str(val)
+
+    async def set_str(self, key: str, value: str, ttl: int | None = None) -> None:
+        await self._redis.set(key, value, ex=ttl)
+
     async def set_worker_token(self, worker_id: str, token: str):
         """Stores the individual token for a specific worker."""
         key = f"orchestrator:worker:token:{worker_id}"

avtomatika/utils/webhook_sender.py

@@ -0,0 +1,54 @@
+from asyncio import sleep
+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
+
+    async def send(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

@@ -29,9 +29,7 @@ class Watcher:
                 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.
+                # We set TTL slightly longer than the expected execution time (60s)
                 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

{avtomatika-1.0b5.dist-info → avtomatika-1.0b7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avtomatika
-Version: 1.0b5
+Version: 1.0b7
 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
@@ -60,6 +59,8 @@ This document serves as a comprehensive guide for developers looking to build pi
   - [Delegating Tasks to Workers (dispatch_task)](#delegating-tasks-to-workers-dispatch_task)
   - [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)
+  - [Webhook Notifications](#webhook-notifications)
 - [Production Configuration](#production-configuration)
   - [Fault Tolerance](#fault-tolerance)
   - [Storage Backend](#storage-backend)
@@ -74,7 +75,17 @@ The project is based on a simple yet powerful architectural pattern that separat
 
 *   **Orchestrator (OrchestratorEngine)** — The Director. It manages the entire process from start to finish, tracks state, handles errors, and decides what should happen next. It does not perform business tasks itself.
 *   **Blueprints (Blueprint)** — The Script. Each blueprint is a detailed plan (a state machine) for a specific business process. It describes the steps (states) and the rules for transitioning between them.
-*   **Workers (Worker)** — The Team of Specialists. These are independent, specialized executors. Each worker knows how to perform a specific set of tasks (e.g., "process video," "send email") and reports back to the Orchestrator.## Installation
+*   **Workers (Worker)** — The Team of Specialists. These are independent, specialized executors. Each worker knows how to perform a specific set of tasks (e.g., "process video," "send email") and reports back to the Orchestrator.
+
+## Ecosystem
+
+Avtomatika is part of a larger ecosystem:
+
+*   **[Avtomatika Worker SDK](https://github.com/avtomatika-ai/avtomatika-worker)**: The official Python SDK for building workers that connect to this engine.
+*   **[RCA Protocol](https://github.com/avtomatika-ai/rca)**: The architectural specification and manifesto behind the system.
+*   **[Full Example](https://github.com/avtomatika-ai/avtomatika-full-example)**: A complete reference project demonstrating the engine and workers in action.
+
+## Installation
 
 *   **Install the core engine only:**
     ```bash
@@ -146,7 +157,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()
     
@@ -328,6 +345,56 @@ async def cache_handler(data_stores):
     user_data = await data_stores.cache.get("user:123")
     print(f"User from cache: {user_data}")
 ```
+
+### 5. Native Scheduler
+
+Avtomatika includes a built-in distributed scheduler. It allows you to trigger blueprints periodically (interval, daily, weekly, monthly) without external tools like cron.
+
+*   **Configuration:** Defined in `schedules.toml`.
+*   **Timezone Aware:** Supports global timezone configuration (e.g., `TZ="Europe/Moscow"`).
+*   **Distributed Locking:** Safe to run with multiple orchestrator instances; jobs are guaranteed to run only once per interval using distributed locks (Redis/Memory).
+
+```toml
+# schedules.toml example
+[nightly_backup]
+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.
+
+*   **Usage:** Pass a `webhook_url` in the request body when creating a job.
+*   **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.
@@ -349,6 +416,12 @@ To manage access and worker settings securely, Avtomatika uses TOML configuratio
     [gpu-worker-01]
     token = "worker-secret-456"
     ```
+-   **`schedules.toml`**: Defines periodic tasks (CRON-like) for the native scheduler.
+    ```toml
+    [nightly_backup]
+    blueprint = "backup_flow"
+    daily_at = "02:00"
+    ```
 
 For detailed specifications and examples, please refer to the [**Configuration Guide**](docs/configuration.md).
 

avtomatika-1.0b7.dist-info/RECORD

@@ -0,0 +1,45 @@
+avtomatika/__init__.py,sha256=D5r3L-H06uxsY_wgfh7u9YR29QvZMer1BlvzjW9Umfo,701
+avtomatika/api.html,sha256=RLx-D1uFCSAXIf_2WgFlSTWrWPcmonNYM-9oNanKXBg,32835
+avtomatika/app_keys.py,sha256=hwg5IBYUsCe-tCru61z3a4-lTw98JL41SXWCmIM_YHc,1161
+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=Tc-vpaQS11i_JTa1pQjGuQD3R5Kj9sIf6gGJGjItBBo,2487
+avtomatika/constants.py,sha256=WL58Nh-EY6baM9Ur_tR9merwPRGb41_klUG2V-yUUaA,963
+avtomatika/context.py,sha256=T6Ux4Fb1DwWRGTpMNeukM51MQDQbGk2HS6Cwpc0dc1s,4248
+avtomatika/data_types.py,sha256=odbkraTYhOo1j3ETIX8NJOy8yIwTdQ_i3juATsjroas,1424
+avtomatika/datastore.py,sha256=gJjhZ5kxjF8pmbbPQb_qu3HPUpfy2c6T75KZ-smb_zg,545
+avtomatika/dispatcher.py,sha256=RrUPvDnCEwAdqxrGpUUcvQZOxG8Ir1E3m9yJjkQeEig,9635
+avtomatika/engine.py,sha256=LZBN4Z50cEITHcrzoYqPS-Rjw4WdPSKRuq-iaBipEbE,15475
+avtomatika/executor.py,sha256=iR9NqS9IffoW692Cq5PKM0P5lmIikmQ65vx8b-D9IZQ,23098
+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=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=WAYTjhVmXyqWZfWfQm-iFDVZFBYpNRfwgGDxa_LCnAI,3354
+avtomatika/worker_config_loader.py,sha256=n0j8gfuJDacWONr8744RsHTCWpc_1ZTRMC-rJZh6P6A,2249
+avtomatika/ws_manager.py,sha256=pi5xe0ivsCjRZw08ri5N-gAChMH2I2YPLpl3E2tP89k,3057
+avtomatika/api/handlers.py,sha256=MO6QkbT001jj4latUXGT0hGOmQf_6TkRkmwx19OcXeQ,22176
+avtomatika/api/routes.py,sha256=vSwj2jJlmftZrjrctt-mNYLF23CfCtlUfaMoZzNOqCk,4895
+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=BYox_3v1qRqfJyyjkjxXj5OmyGBu0EZqz5BWKZy6YsU,12561
+avtomatika/storage/redis.py,sha256=opOhqBL_uCsNXcMD_W_tJU-8wzDUSjBJWEsXrwP2_YM,21035
+avtomatika/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+avtomatika/utils/webhook_sender.py,sha256=sbX6HEED_TvH3MBxFlVrAqP-n68y0q5quYty5b8Z4D8,1941
+avtomatika-1.0b7.dist-info/licenses/LICENSE,sha256=tqCjw9Y1vbU-hLcWi__7wQstLbt2T1XWPdbQYqCxuWY,1072
+avtomatika-1.0b7.dist-info/METADATA,sha256=FVUEaG5_NWobxU5_FDG2l5RmdhvVN5t1quZXQ0GsSpw,24215
+avtomatika-1.0b7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+avtomatika-1.0b7.dist-info/top_level.txt,sha256=gLDWhA_wxHj0I6fG5X8vw9fE0HSN4hTE2dEJzeVS2x8,11
+avtomatika-1.0b7.dist-info/RECORD,,

avtomatika-1.0b5.dist-info/RECORD

@@ -1,37 +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=_XMLdg-iIuXxbmnns17DC8xe8DeLH4xTOCddqUeYxV4,2337
-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=tHYmOCb74gBN-YhxBNVmsE-e5i88wmudLYfK4LWX8Bk,39041
-avtomatika/executor.py,sha256=-SKqLs-DVtMw5P7bZInK57f0M4zRFoVFr1fU5MUrtiY,22543
-avtomatika/health_checker.py,sha256=WXwvRJ-3cZC2Udc_ogsyIQp7VzcvJjq_IaqzkTdE0TE,1265
-avtomatika/logging_config.py,sha256=7RkcdFyhyiCz8MIipDO689mTQVofUJEv-k59QmtqYgc,1368
-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/security.py,sha256=afj28O3xB20EmA75DAQCQm_QKzx_tX2Qv9zE9TlcFvM,4441
-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=CtwupdKGV_gmxcUlbv2xSFadaF8OX2Gul_FYz0K05SE,7551
-avtomatika/history/sqlite.py,sha256=NuuSW9HhzHJcz7_S2otKkudGF4nRVUU2m28ZgVgqMro,8675
-avtomatika/storage/__init__.py,sha256=mGRj_40dWZ7R7uYbqC6gCsUWCKHAbZz4ZVIhYg5dT_E,262
-avtomatika/storage/base.py,sha256=NGQNLPL5z1AX7TzZkQTHAq3gOmLLhhIr8pO-u0VLrBg,10824
-avtomatika/storage/memory.py,sha256=x1FI33KfY6wpGVMY5dGetZR-GAyAajQTg1J2T8slO3U,10938
-avtomatika/storage/redis.py,sha256=of4K5qC_jKMMSj-oyP6rYsAPvTuGLdsLCl4pqfrlhGA,20341
-avtomatika-1.0b5.dist-info/licenses/LICENSE,sha256=tqCjw9Y1vbU-hLcWi__7wQstLbt2T1XWPdbQYqCxuWY,1072
-avtomatika-1.0b5.dist-info/METADATA,sha256=t1mcWWtHdh-SnsTymYpxYNztsQ50mvSz3QxZA4FBWrI,21644
-avtomatika-1.0b5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-avtomatika-1.0b5.dist-info/top_level.txt,sha256=gLDWhA_wxHj0I6fG5X8vw9fE0HSN4hTE2dEJzeVS2x8,11
-avtomatika-1.0b5.dist-info/RECORD,,