avtomatika 1.0b3__py3-none-any.whl → 1.0b5__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."""
@@ -385,22 +451,21 @@ class RedisStorage(StorageBackend):
         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 +484,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.0b3.dist-info → avtomatika-1.0b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avtomatika
-Version: 1.0b3
+Version: 1.0b5
 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"
@@ -334,6 +334,24 @@ The orchestrator's behavior can be configured through environment variables. Add
 
 **Important:** The system employs **strict validation** for configuration files (`clients.toml`, `workers.toml`) at startup. If a configuration file is invalid (e.g., malformed TOML, missing required fields), the application will **fail fast** and exit with an error, rather than starting in a partially broken state. This ensures the security and integrity of the deployment.
 
+### Configuration Files
+
+To manage access and worker settings securely, Avtomatika uses TOML configuration files.
+
+-   **`clients.toml`**: Defines API clients, their tokens, plans, and quotas.
+    ```toml
+    [client_premium]
+    token = "secret-token-123"
+    plan = "premium"
+    ```
+-   **`workers.toml`**: Defines individual tokens for workers to enhance security.
+    ```toml
+    [gpu-worker-01]
+    token = "worker-secret-456"
+    ```
+
+For detailed specifications and examples, please refer to the [**Configuration Guide**](docs/configuration.md).
+
 ### Fault Tolerance
 
 The orchestrator has built-in mechanisms for handling failures based on the `error.code` field in a worker's response.
@@ -342,18 +360,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]"
@@ -418,11 +443,21 @@ To run the `avtomatika` test suite:
 pytest avtomatika/tests/
 ```
 
+### Interactive API Documentation
+
+Avtomatika provides a built-in interactive API documentation page (similar to Swagger UI) that is automatically generated based on your registered blueprints.
+
+*   **Endpoint:** `/_public/docs`
+*   **Features:**
+    *   **List of all system endpoints:** Detailed documentation for Public, Protected, and Worker API groups.
+    *   **Dynamic Blueprint Documentation:** Automatically generates and lists documentation for all blueprints registered in the engine, including their specific API endpoints.
+    *   **Interactive Testing:** Allows you to test API calls directly from the browser. You can provide authentication tokens, parameters, and request bodies to see real server responses.
+
 ## Detailed Documentation
 
-For a deeper dive into the system, please refer to the following documents in the `docs/` directory:
+For a deeper dive into the system, please refer to the following documents:
 
-- [**Architecture Guide**](docs/architecture.md): A detailed overview of the system components and their interactions.
-- [**API Reference**](docs/api_reference.md): Full specification of the HTTP API.
-- [**Deployment Guide**](docs/deployment.md): Instructions for deploying with Gunicorn/Uvicorn and NGINX.
-- [**Cookbook**](docs/cookbook/README.md): Examples and best practices for creating blueprints.
+- [**Architecture Guide**](https://github.com/avtomatika-ai/avtomatika/blob/main/docs/architecture.md): A detailed overview of the system components and their interactions.
+- [**API Reference**](https://github.com/avtomatika-ai/avtomatika/blob/main/docs/api_reference.md): Full specification of the HTTP API.
+- [**Deployment Guide**](https://github.com/avtomatika-ai/avtomatika/blob/main/docs/deployment.md): Instructions for deploying with Gunicorn/Uvicorn and NGINX.
+- [**Cookbook**](https://github.com/avtomatika-ai/avtomatika/blob/main/docs/cookbook/README.md): Examples and best practices for creating blueprints.

avtomatika-1.0b5.dist-info/RECORD

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

avtomatika-1.0b3.dist-info/RECORD

@@ -1,37 +0,0 @@
-avtomatika/__init__.py,sha256=nlk59j7YcK1gapRUVfHjvFZVAD_PZoamgHEptchP3TA,698
-avtomatika/api.html,sha256=Z-Ikqrle7YPXagx2D-C5ylVZicLQFSsIzPsHCQgqMHM,33628
-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=zwouopyGjHkyiE3dMndxu1uAIMOFvnV1h8-ZIFHIH-k,37507
-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.0b3.dist-info/licenses/LICENSE,sha256=tqCjw9Y1vbU-hLcWi__7wQstLbt2T1XWPdbQYqCxuWY,1072
-avtomatika-1.0b3.dist-info/METADATA,sha256=OXavLWy_3WKrw5oW2Q8WdWvAdFFDA1-XvXGN59LQLKM,19455
-avtomatika-1.0b3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-avtomatika-1.0b3.dist-info/top_level.txt,sha256=gLDWhA_wxHj0I6fG5X8vw9fE0HSN4hTE2dEJzeVS2x8,11
-avtomatika-1.0b3.dist-info/RECORD,,