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

avtomatika/storage/redis.py

@@ -1,8 +1,10 @@
 from asyncio import CancelledError, get_running_loop
 from logging import getLogger
-from typing import Any, Dict, Optional
+from os import getenv
+from socket import gethostname
+from typing import Any
 
-from orjson import dumps, loads
+from msgpack import packb, unpackb
 from redis import Redis, WatchError
 from redis.exceptions import NoScriptError, ResponseError
 
@@ -14,23 +16,41 @@ logger = getLogger(__name__)
 class RedisStorage(StorageBackend):
     """Implementation of the state store based on Redis."""
 
-    def __init__(self, redis_client: Redis, prefix: str = "orchestrator:job"):
+    def __init__(
+        self,
+        redis_client: Redis,
+        prefix: str = "orchestrator:job",
+        group_name: str = "orchestrator_group",
+        consumer_name: str | None = None,
+        min_idle_time_ms: int = 60000,
+    ):
         self._redis = redis_client
         self._prefix = prefix
+        self._stream_key = "orchestrator:job_stream"
+        self._group_name = group_name
+        self._consumer_name = consumer_name or getenv("INSTANCE_ID", gethostname())
+        self._group_created = False
+        self._min_idle_time_ms = min_idle_time_ms
 
     def _get_key(self, job_id: str) -> str:
         return f"{self._prefix}:{job_id}"
 
-    async def get_job_state(self, job_id: str) -> Optional[Dict[str, Any]]:
+    @staticmethod
+    def _pack(data: Any) -> bytes:
+        return packb(data, use_bin_type=True)
+
+    @staticmethod
+    def _unpack(data: bytes) -> Any:
+        return unpackb(data, raw=False)
+
+    async def get_job_state(self, job_id: str) -> dict[str, Any] | None:
         """Get the job state from Redis."""
         key = self._get_key(job_id)
         data = await self._redis.get(key)
-        return loads(data) if data else None
+        return self._unpack(data) if data else None
 
-    async def get_priority_queue_stats(self, task_type: str) -> Dict[str, Any]:
+    async def get_priority_queue_stats(self, task_type: str) -> dict[str, Any]:
         """Gets statistics for the priority queue (Sorted Set) for a given task type."""
-        # In our implementation, the queue is tied to the worker type, not the task type.
-        # For simplicity, we assume that the task type corresponds to the worker type.
         worker_type = task_type
         key = f"orchestrator:task_queue:{worker_type}"
 
@@ -63,15 +83,15 @@ class RedisStorage(StorageBackend):
         key = f"orchestrator:task_cancel:{task_id}"
         await self._redis.set(key, "1", ex=3600)
 
-    async def save_job_state(self, job_id: str, state: Dict[str, Any]) -> None:
+    async def save_job_state(self, job_id: str, state: dict[str, Any]) -> None:
         """Save the job state to Redis."""
         key = self._get_key(job_id)
-        await self._redis.set(key, dumps(state))
+        await self._redis.set(key, self._pack(state))
 
     async def update_job_state(
         self,
         job_id: str,
-        update_data: Dict[str, Any],
+        update_data: dict[str, Any],
     ) -> dict[Any, Any] | None | Any:
         """Atomically update the job state in Redis using a transaction."""
         key = self._get_key(job_id)
@@ -81,13 +101,13 @@ class RedisStorage(StorageBackend):
                 try:
                     await pipe.watch(key)
                     current_state_raw = await pipe.get(key)
-                    current_state = loads(current_state_raw) if current_state_raw else {}
+                    current_state = self._unpack(current_state_raw) if current_state_raw else {}
 
                     # Simple dictionary merge. For nested structures, a deep merge may be required.
                     current_state.update(update_data)
 
                     pipe.multi()
-                    pipe.set(key, dumps(current_state))
+                    pipe.set(key, self._pack(current_state))
                     await pipe.execute()
                     return current_state
                 except WatchError:
@@ -96,35 +116,29 @@ class RedisStorage(StorageBackend):
     async def register_worker(
         self,
         worker_id: str,
-        worker_info: Dict[str, Any],
+        worker_info: dict[str, Any],
         ttl: int,
     ) -> None:
-        """Registers a worker in Redis.
-
-        Note: The 'address' key in `worker_info` is no longer used,
-        as in the PULL model, workers initiate the connection with the
-        orchestrator themselves.
-        """
-        # Set default reputation for new workers
+        """Registers a worker in Redis."""
         worker_info.setdefault("reputation", 1.0)
         key = f"orchestrator:worker:info:{worker_id}"
-        await self._redis.set(key, dumps(worker_info), ex=ttl)
+        await self._redis.set(key, self._pack(worker_info), ex=ttl)
 
     async def enqueue_task_for_worker(
         self,
         worker_id: str,
-        task_payload: Dict[str, Any],
+        task_payload: dict[str, Any],
         priority: float,
     ) -> None:
         """Adds a task to the priority queue (Sorted Set) for a worker."""
         key = f"orchestrator:task_queue:{worker_id}"
-        await self._redis.zadd(key, {dumps(task_payload): priority})
+        await self._redis.zadd(key, {self._pack(task_payload): priority})
 
     async def dequeue_task_for_worker(
         self,
         worker_id: str,
         timeout: int,
-    ) -> Optional[Dict[str, Any]]:
+    ) -> dict[str, Any] | None:
         """Retrieves the highest priority task from the queue (Sorted Set),
         using the blocking BZPOPMAX operation.
         """
@@ -132,7 +146,7 @@ class RedisStorage(StorageBackend):
         try:
             # BZPOPMAX returns a tuple (key, member, score)
             result = await self._redis.bzpopmax([key], timeout=timeout)
-            return loads(result[1]) if result else None
+            return self._unpack(result[1]) if result else None
         except CancelledError:
             return None
         except ResponseError as e:
@@ -145,7 +159,7 @@ class RedisStorage(StorageBackend):
                 # Non-blocking fallback for tests
                 res = await self._redis.zpopmax(key)
                 if res:
-                    return loads(res[0][0])
+                    return self._unpack(res[0][0])
             raise e
 
     async def refresh_worker_ttl(self, worker_id: str, ttl: int) -> bool:
@@ -158,9 +172,9 @@ class RedisStorage(StorageBackend):
     async def update_worker_status(
         self,
         worker_id: str,
-        status_update: Dict[str, Any],
+        status_update: dict[str, Any],
         ttl: int,
-    ) -> Optional[Dict[str, Any]]:
+    ) -> dict[str, Any] | None:
         key = f"orchestrator:worker:info:{worker_id}"
         async with self._redis.pipeline(transaction=True) as pipe:
             try:
@@ -169,7 +183,7 @@ class RedisStorage(StorageBackend):
                 if not current_state_raw:
                     return None
 
-                current_state = loads(current_state_raw)
+                current_state = self._unpack(current_state_raw)
 
                 # Create a potential new state to compare against the current one
                 new_state = current_state.copy()
@@ -179,7 +193,7 @@ class RedisStorage(StorageBackend):
 
                 # Only write to Redis if the state has actually changed.
                 if new_state != current_state:
-                    pipe.set(key, dumps(new_state), ex=ttl)
+                    pipe.set(key, self._pack(new_state), ex=ttl)
                     current_state = new_state  # Update the state to be returned
                 else:
                     # If nothing changed, just refresh the TTL to keep the worker alive.
@@ -195,8 +209,8 @@ class RedisStorage(StorageBackend):
     async def update_worker_data(
         self,
         worker_id: str,
-        update_data: Dict[str, Any],
-    ) -> Optional[Dict[str, Any]]:
+        update_data: dict[str, Any],
+    ) -> dict[str, Any] | None:
         key = f"orchestrator:worker:info:{worker_id}"
         async with self._redis.pipeline(transaction=True) as pipe:
             try:
@@ -205,12 +219,12 @@ class RedisStorage(StorageBackend):
                 if not current_state_raw:
                     return None
 
-                current_state = loads(current_state_raw)
+                current_state = self._unpack(current_state_raw)
                 current_state.update(update_data)
 
                 pipe.multi()
                 # Do not set TTL, as this is a data update, not a heartbeat
-                pipe.set(key, dumps(current_state))
+                pipe.set(key, self._pack(current_state))
                 await pipe.execute()
                 return current_state
             except WatchError:
@@ -229,7 +243,7 @@ class RedisStorage(StorageBackend):
             return []
 
         worker_data_list = await self._redis.mget(worker_keys)
-        return [loads(data) for data in worker_data_list if data]
+        return [self._unpack(data) for data in worker_data_list if data]
 
     async def add_job_to_watch(self, job_id: str, timeout_at: float) -> None:
         """Adds a job to a Redis sorted set.
@@ -259,18 +273,74 @@ class RedisStorage(StorageBackend):
         return []
 
     async def enqueue_job(self, job_id: str) -> None:
-        """Adds a job to the Redis queue (list)."""
-        await self._redis.lpush("orchestrator:job_queue", job_id)  # type: ignore[misc]
+        """Adds a job to the Redis stream."""
+        await self._redis.xadd(self._stream_key, {"job_id": job_id})
+
+    async def dequeue_job(self) -> tuple[str, str] | None:
+        """Retrieves a job from the Redis stream using consumer groups.
+        Implements a recovery strategy: checks for pending messages first.
+        """
+        if not self._group_created:
+            try:
+                await self._redis.xgroup_create(self._stream_key, self._group_name, id="0", mkstream=True)
+            except ResponseError as e:
+                if "BUSYGROUP" not in str(e):
+                    raise e
+            self._group_created = True
 
-    async def dequeue_job(self) -> str | None:
-        """Retrieves a job from the Redis queue (list) with blocking."""
         try:
-            # Lock for 1 second so that the while loop in the executor is not too tight
-            result = await self._redis.brpop(["orchestrator:job_queue"], timeout=1)  # type: ignore[misc]
-            return result[1].decode("utf-8") if result else None
+            try:
+                autoclaim_result = await self._redis.xautoclaim(
+                    self._stream_key,
+                    self._group_name,
+                    self._consumer_name,
+                    min_idle_time=self._min_idle_time_ms,
+                    start_id="0-0",
+                    count=1,
+                )
+                if autoclaim_result and autoclaim_result[1]:
+                    messages = autoclaim_result[1]
+                    message_id, data = messages[0]
+                    if data:
+                        job_id = data[b"job_id"].decode("utf-8")
+                        logger.info(f"Reclaimed pending message {message_id} for consumer {self._consumer_name}")
+                        return job_id, message_id.decode("utf-8")
+            except Exception as e:
+                if "unknown command" in str(e).lower() or isinstance(e, ResponseError):
+                    pending_result = await self._redis.xreadgroup(
+                        self._group_name,
+                        self._consumer_name,
+                        {self._stream_key: "0"},
+                        count=1,
+                    )
+                    if pending_result:
+                        stream_name, messages = pending_result[0]
+                        if messages:
+                            message_id, data = messages[0]
+                            job_id = data[b"job_id"].decode("utf-8")
+                            return job_id, message_id.decode("utf-8")
+                else:
+                    raise e
+
+            result = await self._redis.xreadgroup(
+                self._group_name,
+                self._consumer_name,
+                {self._stream_key: ">"},
+                count=1,
+            )
+            if result:
+                stream_name, messages = result[0]
+                message_id, data = messages[0]
+                job_id = data[b"job_id"].decode("utf-8")
+                return job_id, message_id.decode("utf-8")
+            return None
         except CancelledError:
             return None
 
+    async def ack_job(self, message_id: str) -> None:
+        """Acknowledges a message in the Redis stream."""
+        await self._redis.xack(self._stream_key, self._group_name, message_id)
+
     async def quarantine_job(self, job_id: str) -> None:
         """Moves the job ID to the 'quarantine' list in Redis."""
         await self._redis.lpush("orchestrator:quarantine_queue", job_id)  # type: ignore[arg-type]
@@ -290,31 +360,27 @@ class RedisStorage(StorageBackend):
         using a Lua script for atomicity.
         Returns the new value of the counter.
         """
-        # Note: This implementation is simplified for fakeredis compatibility,
-        # which does not support Lua scripting well. In a production Redis,
-        # a Lua script would be more efficient to set the EXPIRE only once.
-        # This version resets the TTL on every call, which is acceptable for tests.
         async with self._redis.pipeline(transaction=True) as pipe:
             pipe.incr(key)
             pipe.expire(key, ttl)
             results = await pipe.execute()
             return results[0]
 
-    async def save_client_config(self, token: str, config: Dict[str, Any]) -> None:
+    async def save_client_config(self, token: str, config: dict[str, Any]) -> None:
         """Saves the static client configuration as a hash."""
         key = f"orchestrator:client_config:{token}"
-        # Convert all values to strings for storage in a Redis hash
-        str_config = {k: dumps(v) for k, v in config.items()}
+        # Convert all values to binary strings for storage in a Redis hash
+        str_config = {k: self._pack(v) for k, v in config.items()}
         await self._redis.hset(key, mapping=str_config)
 
-    async def get_client_config(self, token: str) -> Optional[Dict[str, Any]]:
+    async def get_client_config(self, token: str) -> dict[str, Any] | None:
         """Gets the static client configuration."""
         key = f"orchestrator:client_config:{token}"
         config_raw = await self._redis.hgetall(key)  # type: ignore[misc]
         if not config_raw:
             return None
-        # Decode keys and values, parse JSON
-        return {k.decode("utf-8"): loads(v) for k, v in config_raw.items()}
+        # Decode keys and values, parse binary
+        return {k.decode("utf-8"): self._unpack(v) for k, v in config_raw.items()}
 
     async def initialize_client_quota(self, token: str, quota: int) -> None:
         """Sets or resets the quota counter."""
@@ -370,8 +436,8 @@ class RedisStorage(StorageBackend):
         await self._redis.flushdb()
 
     async def get_job_queue_length(self) -> int:
-        """Returns the length of the job queue list."""
-        return await self._redis.llen("orchestrator:job_queue")
+        """Returns the length of the job stream."""
+        return await self._redis.xlen(self._stream_key)
 
     async def get_active_worker_count(self) -> int:
         """Returns the number of active worker keys."""
@@ -380,27 +446,43 @@ 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}"
         await self._redis.set(key, token)
 
-    async def get_worker_token(self, worker_id: str) -> Optional[str]:
+    async def get_worker_token(self, worker_id: str) -> str | None:
         """Retrieves the individual token for a specific worker."""
         key = f"orchestrator:worker:token:{worker_id}"
         token = await self._redis.get(key)
         return token.decode("utf-8") if token else None
 
-    async def get_worker_info(self, worker_id: str) -> Optional[Dict[str, Any]]:
+    async def get_worker_info(self, worker_id: str) -> dict[str, Any] | None:
         """Gets the full info for a worker by its ID."""
         key = f"orchestrator:worker:info:{worker_id}"
         data = await self._redis.get(key)
-        return loads(data) if data else None
+        return self._unpack(data) if data else None
 
     async def acquire_lock(self, key: str, holder_id: str, ttl: int) -> bool:
         """Attempts to acquire a lock using Redis SET NX."""
         redis_key = f"orchestrator:lock:{key}"
-        # Returns True if set was successful (key didn't exist), None otherwise
         result = await self._redis.set(redis_key, holder_id, nx=True, ex=ttl)
         return bool(result)
 
@@ -419,7 +501,6 @@ class RedisStorage(StorageBackend):
             result = await self._redis.eval(LUA_RELEASE_SCRIPT, 1, redis_key, holder_id)
             return bool(result)
         except ResponseError as e:
-            # Fallback for fakeredis if needed, though fakeredis usually supports eval
             if "unknown command" in str(e):
                 current_val = await self._redis.get(redis_key)
                 if current_val and current_val.decode("utf-8") == holder_id:

avtomatika/worker_config_loader.py

@@ -2,7 +2,7 @@ from hashlib import sha256
 from logging import getLogger
 from os.path import exists
 from tomllib import load
-from typing import Any, Dict
+from typing import Any
 
 from .storage.base import StorageBackend
 
@@ -25,7 +25,7 @@ async def load_worker_configs_to_redis(storage: StorageBackend, config_path: str
 
     try:
         with open(config_path, "rb") as f:
-            workers_config: Dict[str, Any] = load(f)
+            workers_config: dict[str, Any] = load(f)
     except Exception as e:
         logger.error(f"Failed to load or parse worker config file '{config_path}': {e}")
         raise ValueError(f"Invalid worker configuration file: {e}") from e

avtomatika/ws_manager.py

@@ -1,6 +1,5 @@
 from asyncio import Lock
 from logging import getLogger
-from typing import Dict
 
 from aiohttp import web
 
@@ -11,7 +10,7 @@ class WebSocketManager:
     """Manages active WebSocket connections from workers."""
 
     def __init__(self):
-        self._connections: Dict[str, web.WebSocketResponse] = {}
+        self._connections: dict[str, web.WebSocketResponse] = {}
         self._lock = Lock()
 
     async def register(self, worker_id: str, ws: web.WebSocketResponse):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avtomatika
-Version: 1.0b4
+Version: 1.0b6
 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
@@ -17,13 +17,13 @@ Requires-Dist: python-json-logger~=4.0
 Requires-Dist: graphviz~=0.21
 Requires-Dist: zstandard~=0.24
 Requires-Dist: aioprometheus~=23.12
+Requires-Dist: msgpack~=1.1
+Requires-Dist: orjson~=3.11
 Provides-Extra: redis
 Requires-Dist: redis~=7.1; extra == "redis"
-Requires-Dist: orjson~=3.11; extra == "redis"
 Provides-Extra: history
 Requires-Dist: aiosqlite~=0.22; extra == "history"
 Requires-Dist: asyncpg~=0.30; extra == "history"
-Requires-Dist: orjson~=3.11; extra == "history"
 Provides-Extra: telemetry
 Requires-Dist: opentelemetry-api~=1.39; extra == "telemetry"
 Requires-Dist: opentelemetry-sdk~=1.39; extra == "telemetry"
@@ -60,6 +60,7 @@ 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)
 - [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
@@ -328,6 +339,22 @@ 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"
+```
+
 ## 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 +376,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).
 
@@ -360,18 +393,25 @@ The orchestrator has built-in mechanisms for handling failures based on the `err
 *   **PERMANENT_ERROR**: A permanent error (e.g., a corrupted file). The task will be immediately sent to quarantine for manual investigation.
 *   **INVALID_INPUT_ERROR**: An error in the input data. The entire pipeline (Job) will be immediately moved to the failed state.
 
+### Concurrency & Performance
+
+To prevent system overload during high traffic, the Orchestrator implements a backpressure mechanism for its internal job processing logic.
+
+*   **`EXECUTOR_MAX_CONCURRENT_JOBS`**: Limits the number of job handlers running simultaneously within the Orchestrator process (default: `100`). If this limit is reached, new jobs remain in the Redis queue until a slot becomes available. This ensures the event loop remains responsive even with a massive backlog of pending jobs.
+
 ### High Availability & Distributed Locking
 
 The architecture supports horizontal scaling. Multiple Orchestrator instances can run behind a load balancer.
 
 *   **Stateless API:** The API is stateless; all state is persisted in Redis.
+*   **Instance Identity:** Each instance should have a unique `INSTANCE_ID` (defaults to hostname) for correct handling of Redis Streams consumer groups.
 *   **Distributed Locking:** Background processes (`Watcher`, `ReputationCalculator`) use distributed locks (via Redis `SET NX`) to coordinate and prevent race conditions when multiple instances are active.
 
 ### Storage Backend
 
 By default, the engine uses in-memory storage. For production, you must configure persistent storage via environment variables.
 
-*   **Redis (StorageBackend)**: For storing current job states.
+*   **Redis (StorageBackend)**: For storing current job states (serialized with `msgpack`) and managing task queues (using Redis Streams with consumer groups).
     *   Install:
         ```bash
         pip install "avtomatika[redis]"

avtomatika-1.0b6.dist-info/RECORD

@@ -0,0 +1,40 @@
+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,,

avtomatika-1.0b4.dist-info/RECORD

@@ -1,37 +0,0 @@
-avtomatika/__init__.py,sha256=nlk59j7YcK1gapRUVfHjvFZVAD_PZoamgHEptchP3TA,698
-avtomatika/api.html,sha256=RLx-D1uFCSAXIf_2WgFlSTWrWPcmonNYM-9oNanKXBg,32835
-avtomatika/blueprint.py,sha256=Hx5h0upr_IYbCy1ebUTpXw4bnt5yYhgWtdPLVE1_h48,9403
-avtomatika/client_config_loader.py,sha256=zVVHZlxSqZUaNpZ4zoU0T1CFYXdxy-3vKSmPcaFuHSY,2772
-avtomatika/compression.py,sha256=bhA1kw4YrCR3I3kdquZSY0fAzCrRrjtz55uepzLUDKI,2498
-avtomatika/config.py,sha256=0vlMfVMjxwVUC8m_NglGocC_EoklzAc0qmt3UJbxm10,2087
-avtomatika/context.py,sha256=rnF09jqQGkaKlax8P5ku9USwijSm6dommDGZbeVrzLk,4295
-avtomatika/data_types.py,sha256=g-g5hPnCpzeATgOn5v7EvDm5ps314owFJD5iWJ6IPR0,1425
-avtomatika/datastore.py,sha256=ERMyiFYQpAhVYijxzTrrdm6jtIPFf4dngWIa0qod3Wc,551
-avtomatika/dispatcher.py,sha256=a_7DjJwSXbW-ZzqcjZG0ZXMYDD2JLZxpQRIzHOrjeow,9688
-avtomatika/engine.py,sha256=-y_gwj1YK_X3QZ6h02KntVep7vRtZWYf1RYFnXtUmP8,39213
-avtomatika/executor.py,sha256=JHwT2DR-Hbrb_-Le1-mVaXiiQ7z-PkMsuIYB9ciiVo0,21201
-avtomatika/health_checker.py,sha256=WXwvRJ-3cZC2Udc_ogsyIQp7VzcvJjq_IaqzkTdE0TE,1265
-avtomatika/logging_config.py,sha256=e0-eEEGHw1zz9ZshzXaxfavV0uZfamRNdcAeHnrgBYQ,1370
-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=Ir8jbZ_07U8NAcu3r_EXM1jQvNpVEvHRP0k9vsq3mio,2255
-avtomatika/ws_manager.py,sha256=v3nz-w4AhoV_vqs3y8twXaMxm7s52wg2wzCMzTkPd8M,3081
-avtomatika/history/base.py,sha256=p0zItsdxFzd889LujV8py6GwK4CUfqAt8QL915mrT4k,1680
-avtomatika/history/noop.py,sha256=Hk5yJsS4S5G5A7NRRMEafIV_IFI9hddSwEvRg2Reh0M,982
-avtomatika/history/postgres.py,sha256=zanh_WktXM_C8ZPsYGiI1x4ScyHDNE1LVOeYiN72NdY,7685
-avtomatika/history/sqlite.py,sha256=hivl--uJ47MosrD6qhBwW3KYAQvVgbPNM6UYYatqFKM,8862
-avtomatika/storage/__init__.py,sha256=ygqv240XuYuHjU_2eci0J3FWoJLNSRpUFA2GzBrHMKg,259
-avtomatika/storage/base.py,sha256=BCC7uAQrko1UCwZo5kGF-0blwJiFcLCcT-pMnhYAxqY,10494
-avtomatika/storage/memory.py,sha256=7VhQO02SbYc65uDTOY9g43CVOgsodxzg-WYo0JGpUec,11387
-avtomatika/storage/redis.py,sha256=kgNUJuwcxQvCzul0m5COKhDnfJGKReMNeWxtG_BGfLc,18171
-avtomatika-1.0b4.dist-info/licenses/LICENSE,sha256=tqCjw9Y1vbU-hLcWi__7wQstLbt2T1XWPdbQYqCxuWY,1072
-avtomatika-1.0b4.dist-info/METADATA,sha256=o_4U54i5frChX81Jyw6SZcg18RCxloSj5uQ4A8dwilQ,20927
-avtomatika-1.0b4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-avtomatika-1.0b4.dist-info/top_level.txt,sha256=gLDWhA_wxHj0I6fG5X8vw9fE0HSN4hTE2dEJzeVS2x8,11
-avtomatika-1.0b4.dist-info/RECORD,,