investify-utils 2.0.0a9__py3-none-any.whl → 2.0.0a10__py3-none-any.whl

investify_utils/kafka/__init__.py

@@ -1,11 +1,8 @@
 """
-Kafka Avro producer and consumer clients.
+Kafka Avro producer and consumer clients (sync only).
 
-Sync (for Celery workers, scripts):
+Usage:
     from investify_utils.kafka import AvroProducer, AvroConsumer
-
-Async producer (for LangGraph, FastAPI):
-    from investify_utils.kafka import AsyncAvroProducer
 """
 
 
@@ -23,10 +20,6 @@ def __getattr__(name: str):
         from investify_utils.kafka.sync_consumer import OffsetTracker
 
         return OffsetTracker
-    if name == "AsyncAvroProducer":
-        from investify_utils.kafka.async_producer import AsyncAvroProducer
-
-        return AsyncAvroProducer
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
@@ -34,5 +27,4 @@ __all__ = [
     "AvroProducer",
     "AvroConsumer",
     "OffsetTracker",
-    "AsyncAvroProducer",
 ]

{investify_utils-2.0.0a9.dist-info → investify_utils-2.0.0a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investify-utils
-Version: 2.0.0a9
+Version: 2.0.0a10
 Summary: Shared utilities for Investify services
 Author-Email: Investify <dev@investify.vn>
 License: MIT

{investify_utils-2.0.0a9.dist-info → investify_utils-2.0.0a10.dist-info}/RECORD

@@ -1,10 +1,9 @@
-investify_utils-2.0.0a9.dist-info/METADATA,sha256=aJ5o01E-gKq6EmJwHkyDzCjowlBU4gmUN3hxlPWxK5k,3675
-investify_utils-2.0.0a9.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-investify_utils-2.0.0a9.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+investify_utils-2.0.0a10.dist-info/METADATA,sha256=yk0dpTvvrU-C535Jy4yjDXCIpiWZdf94W1jtyw2TRkM,3676
+investify_utils-2.0.0a10.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+investify_utils-2.0.0a10.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
 investify_utils/__init__.py,sha256=sES5ddhmaCRi79i6oax6MhB7H5nJg5QjuG6VV1VI2mc,918
 investify_utils/helpers.py,sha256=1l7nv-P8m-vHQGhjTAJMi-pkvQb8OPzGDIn1KQ499dE,4246
-investify_utils/kafka/__init__.py,sha256=WR4SMKiPCjj1sO9sfSTWEXp_6ltUVJ3-YDF_RmZH2bw,1062
-investify_utils/kafka/async_producer.py,sha256=HtQ5SaL5ShJf7RetO5zItfg9EBFcPj1y18i_V0p-vFg,4752
+investify_utils/kafka/__init__.py,sha256=QAo0koEnQv939_6yys6z4D1cPlXiAjv-m15d1987Yl0,777
 investify_utils/kafka/sync_consumer.py,sha256=NJu9tQ5MrqL7-0Cvtt9Gmq-Qro_O4VVFP85qIKMf_ZM,6305
 investify_utils/kafka/sync_producer.py,sha256=9EyhKZNCgmBgZw50gwSfSRUTnfPnCq520Mh9MHnGVlI,4498
 investify_utils/logging.py,sha256=SyqlpyRd0o_FuO29eB7-5-Fo0mfLRVZP_YHjXcQgjiE,2223
@@ -13,4 +12,4 @@ investify_utils/postgres/async_client.py,sha256=M3F7-AsBJ43WWhfknnvTK9BeiYAyO0R6
 investify_utils/postgres/sync_client.py,sha256=1mozgrNGUUKCR2ETAr9G9dzvW8uG_TmSqcbA63tRpM8,6507
 investify_utils/s3/__init__.py,sha256=0YX-efJTP38Q5XMCyr7u-fXMjCJXkAR7dG817quTns8,399
 investify_utils/s3/sync_client.py,sha256=fj6ejhAu06BUBRe2pnceKaNGhbPM79Xf47geL0DB-i0,6771
-investify_utils-2.0.0a9.dist-info/RECORD,,
+investify_utils-2.0.0a10.dist-info/RECORD,,

investify_utils/kafka/async_producer.py

@@ -1,152 +0,0 @@
-"""
-Asynchronous Avro producer using confluent-kafka with asyncio.
-
-Features:
-- Non-blocking produce with async/await
-- Background asyncio task for polling
-- Suitable for async frameworks (LangGraph, FastAPI)
-
-Usage:
-    from investify_utils.kafka import AsyncAvroProducer
-
-    producer = AsyncAvroProducer(
-        topic="my-topic",
-        subject="my-topic-value",
-        schema_registry_url="http://localhost:8081",
-        bootstrap_servers="localhost:9092",
-    )
-
-    # In async context
-    await producer.produce(key="key1", value={"field": "value"})
-    producer.close()
-"""
-
-import asyncio
-import logging
-from typing import Callable
-
-from confluent_kafka import KafkaException, SerializingProducer
-from confluent_kafka.schema_registry import SchemaRegistryClient, record_subject_name_strategy
-from confluent_kafka.schema_registry.avro import AvroSerializer
-from confluent_kafka.serialization import StringSerializer
-
-logger = logging.getLogger(__name__)
-
-
-class AsyncAvroProducer:
-    """
-    Asynchronous Avro producer for async frameworks.
-
-    Args:
-        topic: Kafka topic name
-        subject: Schema Registry subject name
-        schema_registry_url: Schema Registry URL
-        bootstrap_servers: Kafka bootstrap servers
-        **kwargs: Additional Kafka producer config
-    """
-
-    def __init__(
-        self,
-        topic: str,
-        subject: str,
-        schema_registry_url: str,
-        bootstrap_servers: str,
-        **kwargs,
-    ):
-        self.topic = topic
-        self._schema_registry_url = schema_registry_url
-        self._bootstrap_servers = bootstrap_servers
-        self._subject = subject
-        self._kwargs = kwargs
-        self._producer: SerializingProducer | None = None
-        self._poll_task: asyncio.Task | None = None
-
-    @property
-    def producer(self) -> SerializingProducer:
-        """Lazy producer initialization."""
-        if self._producer is None:
-            schema_registry_client = SchemaRegistryClient({"url": self._schema_registry_url})
-            registered_schema = schema_registry_client.get_latest_version(self._subject)
-            schema_str = registered_schema.schema.schema_str
-
-            avro_serializer = AvroSerializer(
-                schema_registry_client,
-                schema_str,
-                conf={
-                    "auto.register.schemas": False,
-                    "subject.name.strategy": record_subject_name_strategy,
-                },
-            )
-
-            producer_config = {
-                "bootstrap.servers": self._bootstrap_servers,
-                "key.serializer": StringSerializer("utf_8"),
-                "value.serializer": avro_serializer,
-                **self._kwargs,
-            }
-            self._producer = SerializingProducer(producer_config)
-
-            # Start background polling task
-            self._poll_task = asyncio.create_task(self._poll_loop())
-
-        return self._producer
-
-    async def _poll_loop(self) -> None:
-        """Background task for polling delivery callbacks."""
-        while True:
-            self._producer.poll(0.1)
-            await asyncio.sleep(0.1)
-
-    async def produce(
-        self,
-        value: dict,
-        key: str | None = None,
-        on_delivery: Callable | None = None,
-    ) -> asyncio.Future:
-        """
-        Produce a message asynchronously.
-
-        Args:
-            value: Message value (dict matching Avro schema)
-            key: Optional message key
-            on_delivery: Optional callback(err, msg) for delivery confirmation
-
-        Returns:
-            Future that resolves to the delivered message
-        """
-        loop = asyncio.get_running_loop()
-        result = loop.create_future()
-
-        def ack(err, msg):
-            if err:
-                loop.call_soon_threadsafe(result.set_exception, KafkaException(err))
-            else:
-                loop.call_soon_threadsafe(result.set_result, msg)
-            if on_delivery:
-                loop.call_soon_threadsafe(on_delivery, err, msg)
-
-        self.producer.produce(self.topic, key=key, value=value, on_delivery=ack)
-        return await result
-
-    def flush(self, timeout: float = 10.0) -> int:
-        """
-        Wait for all messages to be delivered.
-
-        Args:
-            timeout: Maximum time to wait in seconds
-
-        Returns:
-            Number of messages still in queue
-        """
-        if self._producer:
-            return self._producer.flush(timeout)
-        return 0
-
-    def close(self) -> None:
-        """Cancel polling task and flush pending messages."""
-        if self._poll_task:
-            self._poll_task.cancel()
-            self._poll_task = None
-        if self._producer:
-            self._producer.flush()
-            self._producer = None