ergon-framework-python 0.1.0__py3-none-any.whl

ergon_framework_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,449 @@
+Metadata-Version: 2.4
+Name: ergon-framework-python
+Version: 0.1.0
+Summary: Ergon internal task-oriented project bootstrapper
+Author-email: Ergondata Technologies <anza.vossos@protonmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/danzanellovossos/ergon-framework
+Project-URL: Repository, https://github.com/danzanellovossos/ergon-framework
+Project-URL: Issues, https://github.com/danzanellovossos/ergon-framework/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aio-pika>=9.0.0
+Requires-Dist: aiobotocore>=2.13.0
+Requires-Dist: asyncpg>=0.29.0
+Requires-Dist: boto3>=1.35.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: more-itertools>=10.8.0
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: opentelemetry-api>=1.38.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.38.0
+Requires-Dist: opentelemetry-sdk>=1.38.0
+Requires-Dist: pika>=1.3.0
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: python-json-logger>=4.0.0
+Requires-Dist: requests>=2.32.5
+Dynamic: license-file
+
+# Ergon Framework — Python SDK
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code Style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
+
+**The official Python implementation of the Ergon Framework—a transaction-first, observability-native execution engine for building high-throughput automation pipelines.**
+
+---
+
+## Installation
+
+```bash
+pip install ergon-framework-python
+```
+
+For local development, install in editable mode:
+
+```bash
+pip install -e /path/to/ergon-framework/sdks/python
+```
+
+📖 **[Full Getting Started Guide](docs/getting-started.md)** — Complete setup, project configuration, and task registration
+
+---
+
+## Quick Start
+
+### 1. Define a Consumer Task
+
+Create a task by inheriting from `ConsumerTask` and implementing `process_transaction`:
+
+```python
+from typing import Any
+from ergon.task.mixins import ConsumerTask
+from ergon.connector import Transaction
+
+class OrderProcessor(ConsumerTask):
+    """Consumes order transactions and processes them."""
+
+    def process_transaction(self, transaction: Transaction) -> Any:
+        # Pure business logic—no I/O, no retries, no protocol details
+        order = transaction.payload
+        total = order["quantity"] * order["unit_price"]
+        return {"order_id": order["id"], "total": total, "status": "processed"}
+
+    def handle_process_success(self, transaction: Transaction, result: Any):
+        # Called after successful processing
+        self.output_connector.dispatch_transactions([
+            Transaction(id=f"out-{transaction.id}", payload=result, metadata={})
+        ])
+
+    def handle_process_exception(self, transaction: Transaction, exc: Exception):
+        # Called when processing fails (after all retries exhausted)
+        self.dlq_connector.dispatch_transactions([transaction])
+```
+
+### 2. Create a Connector
+
+Connectors bridge external systems to the transaction interface:
+
+```python
+from typing import List
+from ergon.connector import Connector, Transaction
+import uuid
+
+class RabbitMQConnector(Connector):
+    def __init__(self, queue_name: str, connection_url: str):
+        self.queue_name = queue_name
+        # Initialize your RabbitMQ client here
+        self.client = create_rabbitmq_client(connection_url)
+
+    def fetch_transactions(self, batch_size: int, **kwargs) -> List[Transaction]:
+        messages = self.client.consume(self.queue_name, max_messages=batch_size)
+        return [
+            Transaction(
+                id=str(uuid.uuid4()),
+                payload=msg.body,
+                metadata={"delivery_tag": msg.delivery_tag, "routing_key": msg.routing_key}
+            )
+            for msg in messages
+        ]
+
+    def dispatch_transactions(self, transactions: List[Transaction], **kwargs):
+        for tx in transactions:
+            self.client.publish(self.queue_name, tx.payload)
+```
+
+### 3. Configure and Run
+
+Use `TaskConfig` to wire everything together:
+
+```python
+from ergon.task import TaskConfig, runner, policies
+from ergon.connector import ConnectorConfig
+
+# Configure the consumer policy
+consumer_policy = policies.ConsumerPolicy()
+consumer_policy.name = "consumer"
+consumer_policy.loop.concurrency.value = 5      # Process 5 transactions in parallel
+consumer_policy.loop.batch.size = 10            # Fetch 10 at a time
+consumer_policy.loop.streaming = True           # Keep polling for new messages
+consumer_policy.process.retry.max_attempts = 3  # Retry failed processing 3 times
+consumer_policy.process.retry.backoff = 1.0     # Start with 1s backoff
+consumer_policy.process.retry.backoff_multiplier = 2.0  # Double each retry
+
+# Create the task configuration
+config = TaskConfig(
+    name="order-processor",
+    task=OrderProcessor,
+    max_workers=1,
+    connectors={
+        "input": ConnectorConfig(
+            connector=RabbitMQConnector,
+            kwargs={"queue_name": "orders", "connection_url": "amqp://localhost"}
+        ),
+        "output": ConnectorConfig(
+            connector=RabbitMQConnector,
+            kwargs={"queue_name": "processed-orders", "connection_url": "amqp://localhost"}
+        ),
+    },
+    policies=[consumer_policy],
+)
+
+# Run the task
+if __name__ == "__main__":
+    runner.run(config)
+```
+
+The framework handles the loop, retry logic, telemetry, and graceful shutdown automatically.
+
+---
+
+## The Transaction Object
+
+In the Python SDK, transactions are implemented as immutable Pydantic models:
+
+```python
+from ergon.connector import Transaction
+
+# Transactions are created by Connectors when fetching data
+tx = Transaction(
+    id="tx-001",                           # Unique identifier for tracing
+    payload={"order_id": 123, "amount": 99.99},  # The actual data
+    metadata={"source": "rabbitmq", "queue": "orders"}  # Contextual info
+)
+```
+
+Transactions are **frozen** (immutable) once created via Pydantic's `frozen=True` configuration.
+
+---
+
+## Task Classes
+
+The Python SDK provides ready-to-use task classes:
+
+```python
+from ergon.task.mixins import (
+    ConsumerTask,      # Sync consumer
+    ProducerTask,      # Sync producer
+    HybridTask,        # Sync consumer + producer
+    AsyncConsumerTask, # Async consumer
+    AsyncProducerTask, # Async producer
+    AsyncHybridTask,   # Async consumer + producer
+)
+```
+
+### Synchronous Tasks
+
+Best for CPU-bound processing or legacy libraries:
+
+```python
+from ergon.task.mixins import ConsumerTask
+
+class SyncProcessor(ConsumerTask):
+    def process_transaction(self, transaction):
+        # Runs in ThreadPoolExecutor
+        return heavy_computation(transaction.payload)
+```
+
+- Concurrency controlled by `policy.loop.concurrency.value`
+- Each transaction processed in its own thread
+- Multi-process scaling via `max_workers > 1`
+
+### Asynchronous Tasks
+
+Best for I/O-bound workloads with high concurrency:
+
+```python
+from ergon.task.mixins import AsyncConsumerTask
+
+class AsyncProcessor(AsyncConsumerTask):
+    async def process_transaction(self, transaction):
+        # Runs in asyncio event loop
+        result = await self.http_client.post(transaction.payload)
+        return result
+```
+
+- Concurrency controlled by `asyncio.Semaphore`
+- Thousands of concurrent operations with minimal overhead
+- Perfect for API calls, database queries, network I/O
+
+---
+
+## Dependency Injection
+
+Tasks receive all dependencies automatically via the `TaskMeta` metaclass:
+
+```python
+class EnrichmentTask(ConsumerTask):
+    def process_transaction(self, transaction: Transaction) -> Any:
+        # Access connectors as self.{name}_connector
+        count = self.input_connector.get_transactions_count()
+      
+        # Access services as self.{name}_service
+        enriched = self.openai_service.complete(transaction.payload["text"])
+      
+        # Access policies as self.{name}_policy
+        timeout = self.consumer_policy.loop.timeout
+      
+        return {"enriched": enriched, "pending": count}
+```
+
+Configure services in `TaskConfig`:
+
+```python
+from ergon.connector import ServiceConfig
+
+config = TaskConfig(
+    name="enrichment-task",
+    task=EnrichmentTask,
+    connectors={"input": input_connector_config},
+    services={
+        "openai": ServiceConfig(
+            service=OpenAIService,
+            kwargs={"api_key": "sk-...", "model": "gpt-4"}
+        )
+    },
+    policies=[consumer_policy],
+)
+```
+
+---
+
+## Policy Configuration
+
+Policies are created as instances and configured by setting properties directly:
+
+```python
+from ergon.task import policies
+
+# Consumer policy with full configuration
+policy = policies.ConsumerPolicy()
+policy.name = "my-consumer"
+
+# Loop behavior
+policy.loop.concurrency.value = 10      # Parallel transaction processing
+policy.loop.batch.size = 50             # Transactions per fetch
+policy.loop.streaming = True            # Continuous polling mode
+policy.loop.timeout = 3600              # Max loop duration (seconds)
+policy.loop.limit = 1000                # Max transactions to process
+
+# Empty queue behavior (for streaming mode)
+policy.loop.empty_queue.backoff = 1.0
+policy.loop.empty_queue.backoff_multiplier = 2.0
+policy.loop.empty_queue.backoff_cap = 30.0
+
+# Per-step retry configuration
+policy.fetch.retry.max_attempts = 5
+policy.fetch.retry.timeout = 30
+
+policy.process.retry.max_attempts = 3
+policy.process.retry.backoff = 1.0
+policy.process.retry.backoff_multiplier = 2.0
+policy.process.retry.backoff_cap = 60.0
+
+policy.success.retry.max_attempts = 2
+policy.exception.retry.max_attempts = 2
+```
+
+---
+
+## Observability
+
+The Python SDK integrates **OpenTelemetry** natively:
+
+```python
+from ergon.telemetry import logging, tracing, metrics
+
+config = TaskConfig(
+    name="observed-task",
+    task=MyTask,
+    connectors={...},
+    logging=logging.LoggingConfig(
+        level="INFO",
+        handlers=[
+            logging.ConsoleLogHandler(),
+            logging.OTLPLogHandler(endpoint="http://collector:4317"),
+        ]
+    ),
+    tracing=tracing.TracingConfig(
+        processors=[
+            tracing.SpanProcessor(
+                processor=tracing.BatchSpanProcessor,
+                exporters=[tracing.OTLPSpanExporter(endpoint="http://collector:4317")]
+            )
+        ]
+    ),
+    metrics=metrics.MetricsConfig(
+        readers=[
+            metrics.MetricReader(
+                reader=metrics.PeriodicExportingMetricReader,
+                exporters=[metrics.OTLPMetricExporter(endpoint="http://collector:4317")]
+            )
+        ]
+    ),
+)
+```
+
+### Logging
+
+- Structured JSON logging via `python-json-logger`
+- Automatic `trace_id` and `span_id` injection
+- Multiple handlers: Console, File, RotatingFile, OTLP
+
+### Tracing
+
+- Hierarchical spans: Task → Batch → Transaction → Attempt
+- Full context propagation across async boundaries
+- Export to Jaeger, Tempo, or any OTLP-compatible backend
+
+### Metrics
+
+- Push-based via `PeriodicExportingMetricReader`
+- Automatic resource attributes (task name, host, PID, execution ID)
+- Export to Prometheus, OTLP, or console
+
+---
+
+## Scaling
+
+| Axis                | Mechanism                    | Configuration                              |
+| ------------------- | ---------------------------- | ------------------------------------------ |
+| **Process**   | `ProcessPoolExecutor`      | `TaskConfig.max_workers`                 |
+| **Thread**    | `ThreadPoolExecutor`       | `policy.loop.concurrency.value`          |
+| **Async**     | `asyncio.Semaphore`        | `policy.loop.concurrency.value`          |
+| **Connector** | External system partitioning | Service-specific (consumer groups, shards) |
+
+```python
+# Multi-process scaling (sync tasks only)
+config = TaskConfig(
+    name="scaled-task",
+    task=MyTask,
+    max_workers=4,  # Spawn 4 isolated worker processes
+    connectors={...},
+)
+```
+
+---
+
+## Project Structure
+
+After scaffolding with `ergon init`:
+
+```
+my-project/
+├── main.py                  # Application entry point
+├── _observability/          # Telemetry infrastructure configs
+├── connectors/              # Custom connectors and services
+│   └── {connector_name}/    # One submodule per connector
+│       ├── connector.py     # Transaction interface
+│       └── service.py       # Protocol mechanics
+└── tasks/                   # Task definitions and shared modules
+    ├── settings.py          # Global configs (connectors, services, telemetry)
+    ├── constants.py         # Global constants and enums
+    ├── schemas.py           # Shared Pydantic models
+    ├── exceptions.py        # Shared exception classes
+    ├── helpers.py           # Shared utility functions
+    └── {task_name}/         # Per-task submodule
+        ├── task.py          # Task implementation
+        ├── config.py        # TaskConfig definition
+        ├── schemas.py       # Task-specific models
+        ├── exceptions.py    # Task-specific exceptions
+        └── helpers.py       # Task-specific utilities
+```
+
+📖 **[Full Project Structure Guide](docs/project-structure.md)** — Detailed documentation on organizing connectors, tasks, and shared modules.
+
+---
+
+## Documentation
+
+### Python SDK Guides
+
+- **[Getting Started](docs/getting-started.md)** — Installation, project setup, and running your first task
+- **[CLI Reference](docs/cli.md)** — Commands, options, and exit codes
+- **[Project Structure Guide](docs/project-structure.md)** — How to organize connectors, tasks, and shared modules
+
+### Framework Concepts
+
+- **[Framework Architecture](../../docs/architecture.md)** — Full system specification and design philosophy
+- **[Transaction Abstraction](../../docs/modules/1.transaction.md)** — Understanding atomicity rules
+- **[Task Module](../../docs/modules/2.task.md)** — Mixins, lifecycles, and execution modes
+- **[Connector Module](../../docs/modules/3.connector.md)** — Building integration boundaries
+- **[Service Module](../../docs/modules/4.service.md)** — Protocol engineering and reliability
+- **[Telemetry Module](../../docs/modules/5.telemetry.md)** — Configuring OTel logs, metrics, and traces
+
+---
+
+## License
+
+This project is licensed under the [MIT License](../../LICENSE).
+
+<br/>

ergon_framework_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,82 @@
+ergon/__init__.py,sha256=SE3PIboMgB-F2SrifSZA_gQY4WsTsPK-eoCbj5Qpejw,218
+ergon/cli.py,sha256=CF8PvOjIguR18a657aEBEyhFXUoSVtSRVXv5PfnuWtA,6021
+ergon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ergon/bootstrap/src/__project__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ergon/bootstrap/src/__project__/main.py,sha256=lIxQJL7084Y_QljrC9FZOC-JB5_loGjaIrB2GblCj8k,94
+ergon/bootstrap/src/__project__/_observability/docker-compose.telemetry.yml,sha256=NUZDal-azFdsLoSGEOu5WmkfUey6rwjBqw4Om31DTE4,3529
+ergon/bootstrap/src/__project__/_observability/grafana.yaml,sha256=2pJqqzHvaD45GHoJCkD-9nPI5XC-LErtPAcHkX3zHpY,272
+ergon/bootstrap/src/__project__/_observability/loki.yaml,sha256=b-WGzuIb9ZvZ5-m4oZYrDTg-gYrJc7JQLVd22pYESVg,948
+ergon/bootstrap/src/__project__/_observability/otel-collector-config.yaml,sha256=wlzGr9FhOi9lMKaqdjm4paana-zZv5M6WEGHhq6S_8U,1062
+ergon/bootstrap/src/__project__/_observability/prometheus.yaml,sha256=1KKGqBBf4MXJuSJrLJ0v26ufrqLnRu9nvmAOUTXNHOw,228
+ergon/bootstrap/src/__project__/_observability/tempo.yaml,sha256=QFohNJh4F3asgjXfrhZOwMbiIMSy3sfhB7-XM1zXikA,336
+ergon/bootstrap/src/__project__/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ergon/bootstrap/src/__project__/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ergon/bootstrap/src/__project__/tasks/constants.py,sha256=svwn3_nOy77EaqW_Sgbh0Pb-kRX4eWL5O9elK9xo_f4,324
+ergon/bootstrap/src/__project__/tasks/exceptions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ergon/bootstrap/src/__project__/tasks/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ergon/bootstrap/src/__project__/tasks/schemas.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ergon/bootstrap/src/__project__/tasks/settings.py,sha256=eSNkPgepRMTDx01fOLl4DhFWVOwXiK6Em2tlDPFMO94,172
+ergon/bootstrap/src/__project__/tasks/example_task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ergon/bootstrap/src/__project__/tasks/example_task/config.py,sha256=kGzV5bXQfylXf6ZNE-hRp19RarL3Pufo1hyxOPZIqRk,112
+ergon/bootstrap/src/__project__/tasks/example_task/exceptions.py,sha256=LTWwquhM0izJnpsv3uHcRLZ-wkZCb4ZTOwsmX_am104,144
+ergon/bootstrap/src/__project__/tasks/example_task/helpers.py,sha256=uR_XZEtxR6JzbJloi7OhJb77f7Wc6pnOe1W3CHvl8vE,122
+ergon/bootstrap/src/__project__/tasks/example_task/schemas.py,sha256=3_qANKlJIQ90gaRNrDuBAM42UNzfDbLI4-F0kkjjWHc,155
+ergon/bootstrap/src/__project__/tasks/example_task/task.py,sha256=XnmVg-B0N8Ld48FMLJgGfTTJLjmpy5Nog_Gaj1ruVEQ,36
+ergon/connector/__init__.py,sha256=Ij7SZhlfrPSr8pycZ1qFZra7HwAhLvaDXaaKS8kZMSg,1546
+ergon/connector/connector.py,sha256=jaF1iXKALE1IHHfcP54mTD5mvj-wzk5iNaLo96IOcDI,3944
+ergon/connector/transaction.py,sha256=LMGEFfisdjGGCPrWps3nYJ-SRBKa-P2pOFmwbSgDN-E,291
+ergon/connector/excel/__init__.py,sha256=FHaqlDXAzV7dmsg3sy3N-3nxFbUswMsp5DdGC7o07p0,480
+ergon/connector/excel/connector.py,sha256=Tx2T9Ggo8pPAaSmua4j_PMu_QiiiezWm1Nru3Jr0E94,5327
+ergon/connector/excel/models.py,sha256=9RSCaFJAaFTTI0BMZ8S87SWvRqpEsMA50Mw7Gc47_dE,905
+ergon/connector/excel/service.py,sha256=H6T4oJ46espyHXoJRLsZT7gEje5elqYozChsRPI4aXc,3339
+ergon/connector/pipefy/__init__.py,sha256=sTI6QMGOi7aMIEzyo56ZzH3KlvWkjaX7Zun1fOv2FOM,477
+ergon/connector/pipefy/async_connector.py,sha256=Ls4fRcTD21gWbeSj32WpSID6b5ZYTNBjWN7kNw-9Ey0,1739
+ergon/connector/pipefy/async_service.py,sha256=Kpd-LVTet3Ve6z85pUWZ2uUWFpgTaF74znbKFzmXAMA,26298
+ergon/connector/pipefy/connector.py,sha256=kPeTfkpfO8V90PRTmVRGJaHD5z4emHepW7LUoa1x3Uw,1311
+ergon/connector/pipefy/models.py,sha256=LrWAFqtNWdPkBI5m73MEytd0PckcG9kUOzMAOJS8or4,2014
+ergon/connector/pipefy/service.py,sha256=n8kf2bMNLBK4Fabj9JLq-wr3Llah8z7pK3Iz8mTB-yk,29139
+ergon/connector/pipefy/version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+ergon/connector/postgres/__init__.py,sha256=8KAlpq2wwnkz1Az-e8YuBcrdMqFc6M-jauuwvvCdeLQ,338
+ergon/connector/postgres/async_connector.py,sha256=LgZlN93_fjqFxZ6UPVJ1HbAVHXpS4itW8eCtzqHk1U4,3973
+ergon/connector/postgres/async_service.py,sha256=PdPnNElMKzLoov1as3Kcb_viuSyBaVE6WzgKRjsJ82E,4126
+ergon/connector/postgres/models.py,sha256=DL9wBdZ6QZPH1iVft71cTabnFUCH1Hg1RmG5f5E8578,1749
+ergon/connector/rabbitmq/__init__.py,sha256=UVd16TEBVU_C9A7Uy-1JfhxZrWsRChh4qGFp6_rsXSw,673
+ergon/connector/rabbitmq/async_connector.py,sha256=yQ-1QJvoOFO4QM5z7BrdzmyoGPP8aZYd31jiYjeWybo,4583
+ergon/connector/rabbitmq/async_service.py,sha256=VEPedxp0n3eER5kgl5j86MEPZy1P5uXVjO2gebGE1lA,17172
+ergon/connector/rabbitmq/connector.py,sha256=vsSzbVuuE8rKkwBfPgD97qTsqADxJGALnUvrEwZIL5Q,1633
+ergon/connector/rabbitmq/helper.py,sha256=xlQGx2SGR2DC1fi-5BMlCOvWydWEFkcN7fPJjlNvGLA,372
+ergon/connector/rabbitmq/models.py,sha256=9Zr6xJCIIDzVtL0Hdf2I1hpvNpUxH1c9nvy1UbwtFFg,5515
+ergon/connector/rabbitmq/service.py,sha256=U-KVWtYec630SnexXe-8qmmiMpwYwKhW7lossxbponM,7109
+ergon/connector/sqs/__init__.py,sha256=yagjZQ_uQDo20p18x9gnUsixKUaos_yskQ8RkwFUlcE,394
+ergon/connector/sqs/async_connector.py,sha256=GX2VYplDl5veVwbl2m1sicnWbUHti45x27PUSBq5n6Q,4544
+ergon/connector/sqs/async_service.py,sha256=78kVRkhXxwjM36kohTGneO3Yi-otsyf1mUrL9QeeJ3Q,8565
+ergon/connector/sqs/connector.py,sha256=2kqiEGogQtygjNZk9NPSOSKcjrs67mOERF0LZKjIvbI,4454
+ergon/connector/sqs/models.py,sha256=8NoNxmyV3MmTxQ3sytjok5fa4KpTr1J8-C62x-v1vXo,2064
+ergon/connector/sqs/service.py,sha256=DgeJg_Mjw6iV2EWnEU1RQty53BiXh5aDqLzExspH3Kg,7504
+ergon/service/__init__.py,sha256=UrjnIUFqFzkhKYZP8dmMO_i_pKMmwqeY0JcexvKvAGY,71
+ergon/service/service.py,sha256=X4XaeHTKokkz7TGqR0VaNM1nUQSytR91Zukxj1k48X4,384
+ergon/task/__init__.py,sha256=ekzzJ4fc-qkxy24trjvPc0T63FiOfrOudGommO04VMo,241
+ergon/task/base.py,sha256=oD0moP4nMbEbuAvfjGEC0VcFx1BznLQ1LDj_ESR2KPU,6640
+ergon/task/exceptions.py,sha256=92Kxtj5BRastdvFex7SskPu3VUEqqJyO76bb2mODof8,6824
+ergon/task/helpers.py,sha256=Nyo3csTLtD5UHMhQJV3gJyWKBcZxH9K8H-RQO9g_pA4,21798
+ergon/task/manager.py,sha256=3Xr8RPRjtCEoupMeyYb19uK0TQhoVehFlBZd8ZFZ-YA,2972
+ergon/task/policies.py,sha256=mGb8iafrkVf438xiAUh0FpXqfgtNAM7RyoaF8jHNf80,7042
+ergon/task/runner.py,sha256=5uTGlNcm7PfWSp95zBPwn91pVKdbxdfMK4N68HGPoSM,12945
+ergon/task/utils.py,sha256=OmlP2AhLM32V8O9OMky6DdSvxwmMNn9x2LTguf0y-M0,2501
+ergon/task/mixins/__init__.py,sha256=6A8vNgdjaQYNJvymWNF-kBN2oTaQBYRLctS3Sq1w_-Y,320
+ergon/task/mixins/consumer.py,sha256=B1oX0XfB6hfNnbBf4dpiuxSn5vy-APvnZOZGZw5FZQs,37954
+ergon/task/mixins/metrics.py,sha256=4bavwo8koWiN5ADD8t5qd2BVeVcgxo6ddzq-xOybeTg,13159
+ergon/task/mixins/producer.py,sha256=xENTZdZ7t0dpw5YsreQT20iTycSaj1EA4ny-60u-SWM,20427
+ergon/telemetry/__init__.py,sha256=8waeIAHEx6tMXWfw-zOEKgjrg7V8S1poG070MdAmi_8,100
+ergon/telemetry/_resource.py,sha256=5uf6qG-6tIt2VOO7nZ7vmqUCBoeD0O6U37fGedJZrws,566
+ergon/telemetry/logging.py,sha256=ltHKy6_hUinRJBGMdmpNeJs1C_TcPZMG4EHE-O1Tm8E,11385
+ergon/telemetry/metrics.py,sha256=0T_CuNw9P5AG1U9k1-bNp1g7McyiNLUIt_zKyLOtrnA,2841
+ergon/telemetry/tracing.py,sha256=_ktiZWAgB1DU-uN91Mzr0iYNXxbCN21LnKiRo5SOJxY,4454
+ergon/utils/__init__.py,sha256=M0_VCjMN7jvSPlRZLZHeFKTHAl1zu3BnAhjrzJjDfiI,57
+ergon/utils/env.py,sha256=lji4xENvfHqg2GTGnzG95VKpxxM4f3DHIKKP61xQG08,621
+ergon_framework_python-0.1.0.dist-info/licenses/LICENSE,sha256=bWCIhHzaadz_ecLdCdtwyMafeQ17s2d7_FSSuSuEcDs,1079
+ergon_framework_python-0.1.0.dist-info/METADATA,sha256=UKmLy8Z2Jxs1fozWY3CVDHfU9jduMvhiLXGZTmuSPE0,14739
+ergon_framework_python-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ergon_framework_python-0.1.0.dist-info/entry_points.txt,sha256=reZ934txb5OrtcNBgTGqCsXa1biUDQWubD2a9fGZynE,42
+ergon_framework_python-0.1.0.dist-info/top_level.txt,sha256=KSPt6N7RzsjU7PRAalWQ9Cul7YTUxbo84yAJ-y2vLm8,6
+ergon_framework_python-0.1.0.dist-info/RECORD,,

ergon_framework_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ergon_framework_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ergon = ergon.cli:ergon

ergon_framework_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ergondata-Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ergon_framework_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ergon