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

avtomatika/executor.py

@@ -1,5 +1,4 @@
 from asyncio import CancelledError, Task, create_task, sleep
-from inspect import signature
 from logging import getLogger
 from time import monotonic
 from types import SimpleNamespace
@@ -167,17 +166,17 @@ class JobExecutor:
                         handler = blueprint.find_handler(context.current_state, context)
 
                     # Build arguments for the handler dynamically.
-                    handler_signature = signature(handler)
-                    params_to_inject = {}
+                    param_names = blueprint.get_handler_params(handler)
+                    params_to_inject: dict[str, Any] = {}
 
-                    if "context" in handler_signature.parameters:
+                    if "context" in param_names:
                         params_to_inject["context"] = context
-                        if "actions" in handler_signature.parameters:
+                        if "actions" in param_names:
                             params_to_inject["actions"] = action_factory
                     else:
                         # New injection logic with prioritized lookup.
                         context_as_dict = context._asdict()
-                        for param_name in handler_signature.parameters:
+                        for param_name in param_names:
                             # Look in JobContext fields first.
                             if param_name in context_as_dict:
                                 params_to_inject[param_name] = context_as_dict[param_name]
@@ -232,7 +231,7 @@ class JobExecutor:
         job_state: dict[str, Any],
         next_state: str,
         duration_ms: int,
-    ):
+    ) -> None:
         job_id = job_state["id"]
         previous_state = job_state["current_state"]
         logger.info(f"Job {job_id} transitioning from {previous_state} to {next_state}")
@@ -260,13 +259,19 @@ class JobExecutor:
         else:
             logger.info(f"Job {job_id} reached terminal state {next_state}")
             await self._check_and_resume_parent(job_state)
+            # Send webhook for finished/failed jobs
+            event_type = "job_finished" if next_state == "finished" else "job_failed"
+            # Since _check_and_resume_parent is for sub-jobs, we only send webhook if it's a top-level job
+            # or if the user explicitly requested it for sub-jobs (by providing webhook_url).
+            # The current logic stores webhook_url in job_state, so we just check it.
+            await self.engine.send_job_webhook(job_state, event_type)
 
     async def _handle_dispatch(
         self,
         job_state: dict[str, Any],
         task_info: dict[str, Any],
         duration_ms: int,
-    ):
+    ) -> None:
         job_id = job_state["id"]
         current_state = job_state["current_state"]
 
@@ -302,7 +307,6 @@ class JobExecutor:
             await self.storage.save_job_state(job_id, job_state)
             await self.storage.add_job_to_watch(job_id, timeout_at)
 
-            # Now, dispatch the task
             await self.dispatcher.dispatch(job_state, task_info)
 
     async def _handle_run_blueprint(
@@ -310,7 +314,7 @@ class JobExecutor:
         parent_job_state: dict[str, Any],
         sub_blueprint_info: dict[str, Any],
         duration_ms: int,
-    ):
+    ) -> None:
         parent_job_id = parent_job_state["id"]
         child_job_id = str(uuid4())
 
@@ -350,7 +354,7 @@ class JobExecutor:
         job_state: dict[str, Any],
         parallel_info: dict[str, Any],
         duration_ms: int,
-    ):
+    ) -> None:
         job_id = job_state["id"]
         tasks_to_dispatch = parallel_info["tasks"]
         aggregate_into = parallel_info["aggregate_into"]
@@ -398,7 +402,7 @@ class JobExecutor:
         job_state: dict[str, Any],
         error: Exception,
         duration_ms: int,
-    ):
+    ) -> None:
         """Handles failures that occur *during the execution of a handler*.
 
         This is different from a task failure reported by a worker. This logic
@@ -447,13 +451,14 @@ class JobExecutor:
             await self.storage.quarantine_job(job_id)
             # If this quarantined job was a sub-job, we must now resume its parent.
             await self._check_and_resume_parent(job_state)
+            await self.engine.send_job_webhook(job_state, "job_quarantined")
             from . import metrics
 
             metrics.jobs_failed_total.inc(
                 {metrics.LABEL_BLUEPRINT: job_state.get("blueprint_name", "unknown")},
             )
 
-    async def _check_and_resume_parent(self, child_job_state: dict[str, Any]):
+    async def _check_and_resume_parent(self, child_job_state: dict[str, Any]) -> None:
         """Checks if a completed job was a sub-job. If so, it resumes the parent
         job, passing the success/failure outcome of the child.
         """
@@ -493,7 +498,7 @@ class JobExecutor:
         await self.storage.enqueue_job(parent_job_id)
 
     @staticmethod
-    def _handle_task_completion(task: Task):
+    def _handle_task_completion(task: Task) -> None:
         """Callback to handle completion of a job processing task."""
         try:
             # This will re-raise any exception caught in the task
@@ -505,7 +510,7 @@ class JobExecutor:
             # Log any other exceptions that occurred in the task.
             logger.exception("Unhandled exception in job processing task")
 
-    async def run(self):
+    async def run(self) -> None:
         import asyncio
 
         logger.info("JobExecutor started.")
@@ -536,5 +541,5 @@ class JobExecutor:
                 await sleep(1)
         logger.info("JobExecutor stopped.")
 
-    def stop(self):
+    def stop(self) -> None:
         self._running = False

avtomatika/scheduler.py

@@ -21,7 +21,7 @@ class Scheduler:
         self.schedules: list[ScheduledJobConfig] = []
         self.timezone = ZoneInfo(self.config.TZ)
 
-    def load_config(self):
+    def load_config(self) -> None:
         if not self.config.SCHEDULES_CONFIG_PATH:
             logger.info("No SCHEDULES_CONFIG_PATH set. Scheduler will not run any jobs.")
             return
@@ -32,7 +32,7 @@ class Scheduler:
         except Exception as e:
             logger.error(f"Failed to load schedules config: {e}")
 
-    async def run(self):
+    async def run(self) -> None:
         self.load_config()
         if not self.schedules:
             logger.info("No schedules found. Scheduler loop will not start.")
@@ -59,22 +59,22 @@ class Scheduler:
 
         logger.info("Scheduler stopped.")
 
-    def stop(self):
+    def stop(self) -> None:
         self._running = False
 
-    async def _process_job(self, job: ScheduledJobConfig, now_tz: datetime):
+    async def _process_job(self, job: ScheduledJobConfig, now_tz: datetime) -> None:
         if job.interval_seconds:
             await self._process_interval_job(job, now_tz)
         else:
             await self._process_calendar_job(job, now_tz)
 
-    async def _process_interval_job(self, job: ScheduledJobConfig, now_tz: datetime):
+    async def _process_interval_job(self, job: ScheduledJobConfig, now_tz: datetime) -> None:
         last_run_key = f"scheduler:last_run:{job.name}"
         last_run_ts = await self.storage.get_str(last_run_key)
 
         now_ts = now_tz.timestamp()
 
-        if last_run_ts and now_ts - float(last_run_ts) < job.interval_seconds:
+        if last_run_ts and job.interval_seconds is not None and now_ts - float(last_run_ts) < job.interval_seconds:
             return
 
         lock_key = f"scheduler:lock:interval:{job.name}"
@@ -85,7 +85,7 @@ class Scheduler:
             except Exception as e:
                 logger.error(f"Failed to trigger interval job {job.name}: {e}")
 
-    async def _process_calendar_job(self, job: ScheduledJobConfig, now_tz: datetime):
+    async def _process_calendar_job(self, job: ScheduledJobConfig, now_tz: datetime) -> None:
         target_time_str = job.daily_at or job.time
         if not target_time_str:
             return
@@ -110,7 +110,7 @@ class Scheduler:
             logger.info(f"Triggering scheduled job {job.name}")
             await self._trigger_job(job)
 
-    async def _trigger_job(self, job: ScheduledJobConfig):
+    async def _trigger_job(self, job: ScheduledJobConfig) -> None:
         try:
             await self.engine.create_background_job(
                 blueprint_name=job.blueprint, initial_data=job.input_data, source=f"scheduler:{job.name}"

avtomatika/storage/memory.py

@@ -33,7 +33,7 @@ class MemoryStorage(StorageBackend):
         async with self._lock:
             return self._jobs.get(job_id)
 
-    async def _clean_expired(self):
+    async def _clean_expired(self) -> None:
         """Helper to remove expired keys."""
         now = monotonic()
 
@@ -47,7 +47,7 @@ class MemoryStorage(StorageBackend):
             self._worker_ttls.pop(k, None)
             self._workers.pop(k, None)
 
-    async def save_job_state(self, job_id: str, state: dict[str, Any]):
+    async def save_job_state(self, job_id: str, state: dict[str, Any]) -> None:
         async with self._lock:
             self._jobs[job_id] = state
 
@@ -102,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
 
@@ -141,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()
@@ -202,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:
@@ -223,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

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.0b6.dist-info → avtomatika-1.0b7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avtomatika
-Version: 1.0b6
+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
@@ -61,6 +60,7 @@ 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)
+  - [Webhook Notifications](#webhook-notifications)
 - [Production Configuration](#production-configuration)
   - [Fault Tolerance](#fault-tolerance)
   - [Storage Backend](#storage-backend)
@@ -157,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()
     
@@ -355,6 +361,40 @@ 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.

{avtomatika-1.0b6.dist-info → avtomatika-1.0b7.dist-info}/RECORD

@@ -1,16 +1,17 @@
 avtomatika/__init__.py,sha256=D5r3L-H06uxsY_wgfh7u9YR29QvZMer1BlvzjW9Umfo,701
 avtomatika/api.html,sha256=RLx-D1uFCSAXIf_2WgFlSTWrWPcmonNYM-9oNanKXBg,32835
-avtomatika/blueprint.py,sha256=jU1Un9yiIUbZ9I7k20XyAhnMbXyrnkC0AakMX3GbK6k,9207
+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=MT_RMMxSCAVEhlo5HUQdQ1uaR86D9d4s_3nrd6O5xAg,4241
-avtomatika/data_types.py,sha256=VWWbTcJaQt43JaD09qZL1spwNdzCR9vPXVthlM133gM,1362
+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=Tsye9zOcLN2c7O0AalbX9Il5l3XdT64UDV7iQKiLIJE,9627
-avtomatika/engine.py,sha256=fSCalpR3-j-ATmDE5XMYjz1PSubVcrbeMFWGX_NRI8g,41883
-avtomatika/executor.py,sha256=-SKqLs-DVtMw5P7bZInK57f0M4zRFoVFr1fU5MUrtiY,22543
+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
@@ -18,23 +19,27 @@ 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.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=IHaqSqp3XSGXjRY-LEeTG9BJpq2nqJSnmjY_Vdvk3jo,3493
+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=Px_ISqZz5Nhl5wLvGpMqY21-eKaLfkzgof7jquCmHaM,12234
+avtomatika/storage/memory.py,sha256=BYox_3v1qRqfJyyjkjxXj5OmyGBu0EZqz5BWKZy6YsU,12561
 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/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,,