fastkafka2 0.1.0__tar.gz

fastkafka2-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: fastkafka2
+Version: 0.1.0
+Summary: Next-generation FastAPI-like DX for Kafka (version 2)
+Author: Ruslan Ramazanov
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.6
+Requires-Dist: anyio>=4
+Requires-Dist: aiokafka>=0.10
+Requires-Dist: typing-extensions>=4.8
+
+# fastkafka2
+
+Next-generation FastAPI-like DX for Kafka (version 2).
+
+## Installation
+
+``` bash
+pip install fastkafka2
+```
+
+## Use example
+### Project arch
+```shell
+├── api/
+│   ├── kafka/
+│   │   ├── handlers/
+│   │   │   ├── example/
+│   │   │   │   ├─ schemas.py
+│   │   │   │   └─ handler.py
+│   │   │   └── base_handler.py
+│   │   └── lifespan.py
+│
+├── main.py
+```
+
+### Schemas
+``` python
+# api\kafka\handlers\example\schemas.py
+from pydantic import BaseModel
+
+
+class ExampleSchema(BaseModel):
+    msg: str
+```
+
+### Handler
+``` python
+# api\kafka\handlers\example\handler.py
+import logging
+
+from fastkafka.handler import KafkaHandler
+from fastkafka.message import KafkaMessage
+from fastkafka.producer import KafkaProducer
+
+
+handler = KafkaHandler()
+
+kafka_producer = KafkaProducer(bootstrap_servers="127.0.0.1:9092")
+
+
+@handler("example")
+async def example_handler(message: KafkaMessage):
+    t = int(message.headers.get("try")) + 1
+    logging.info(f"Пришло: {message}")
+    await kafka_producer.send_message(
+        topic="example-2", data={"msg": "wddwd"}, headers={"try": f"{t}"}, key=None
+    )
+    logging.info(f"Отправил: {f'{t}'}")
+```
+
+
+### Grouping of handlers
+``` python
+# api\kafka\handlers\base_handler.py
+from api.kafka.handlers.example.handler import handler as example_handler
+
+from fastkafka.handler import KafkaHandler
+
+base_handler = KafkaHandler()
+
+base_handler.include_handler(example_handler)
+```
+
+
+### Lifespan fastkafka app
+``` python
+# api/kafka/lifespan.py
+import logging
+from contextlib import asynccontextmanager
+from fastkafka.app import KafkaApp
+from api.kafka.handlers.base_handler import base_handler
+
+from api.kafka.handlers.example.handler import kafka_producer
+
+
+@asynccontextmanager
+async def lifespan(app: KafkaApp):
+    logging.info("Lifespan: запуск")
+    try:
+        await kafka_producer.start()
+        yield
+        logging.info("Lifespan: выполнен")
+    finally:
+        await kafka_producer.stop()
+        logging.info("Lifespan: остановка")
+
+
+app = KafkaApp(
+    title="Kafka Gateway",
+    description="Kafka-based microservice",
+    bootstrap_servers="127.0.0.1:9092",
+    lifespan=lifespan,
+)
+
+app.include_handler(base_handler)
+```
+
+
+### Entry point main app
+``` python
+# main.py
+import asyncio
+from logging_config import setup_logging
+from api.kafka.lifespan import app
+
+if __name__ == "__main__":
+    setup_logging()
+    asyncio.run(app.run())
+```
+
+

fastkafka2-0.1.0/README.md

@@ -0,0 +1,121 @@
+# fastkafka2
+
+Next-generation FastAPI-like DX for Kafka (version 2).
+
+## Installation
+
+``` bash
+pip install fastkafka2
+```
+
+## Use example
+### Project arch
+```shell
+├── api/
+│   ├── kafka/
+│   │   ├── handlers/
+│   │   │   ├── example/
+│   │   │   │   ├─ schemas.py
+│   │   │   │   └─ handler.py
+│   │   │   └── base_handler.py
+│   │   └── lifespan.py
+│
+├── main.py
+```
+
+### Schemas
+``` python
+# api\kafka\handlers\example\schemas.py
+from pydantic import BaseModel
+
+
+class ExampleSchema(BaseModel):
+    msg: str
+```
+
+### Handler
+``` python
+# api\kafka\handlers\example\handler.py
+import logging
+
+from fastkafka.handler import KafkaHandler
+from fastkafka.message import KafkaMessage
+from fastkafka.producer import KafkaProducer
+
+
+handler = KafkaHandler()
+
+kafka_producer = KafkaProducer(bootstrap_servers="127.0.0.1:9092")
+
+
+@handler("example")
+async def example_handler(message: KafkaMessage):
+    t = int(message.headers.get("try")) + 1
+    logging.info(f"Пришло: {message}")
+    await kafka_producer.send_message(
+        topic="example-2", data={"msg": "wddwd"}, headers={"try": f"{t}"}, key=None
+    )
+    logging.info(f"Отправил: {f'{t}'}")
+```
+
+
+### Grouping of handlers
+``` python
+# api\kafka\handlers\base_handler.py
+from api.kafka.handlers.example.handler import handler as example_handler
+
+from fastkafka.handler import KafkaHandler
+
+base_handler = KafkaHandler()
+
+base_handler.include_handler(example_handler)
+```
+
+
+### Lifespan fastkafka app
+``` python
+# api/kafka/lifespan.py
+import logging
+from contextlib import asynccontextmanager
+from fastkafka.app import KafkaApp
+from api.kafka.handlers.base_handler import base_handler
+
+from api.kafka.handlers.example.handler import kafka_producer
+
+
+@asynccontextmanager
+async def lifespan(app: KafkaApp):
+    logging.info("Lifespan: запуск")
+    try:
+        await kafka_producer.start()
+        yield
+        logging.info("Lifespan: выполнен")
+    finally:
+        await kafka_producer.stop()
+        logging.info("Lifespan: остановка")
+
+
+app = KafkaApp(
+    title="Kafka Gateway",
+    description="Kafka-based microservice",
+    bootstrap_servers="127.0.0.1:9092",
+    lifespan=lifespan,
+)
+
+app.include_handler(base_handler)
+```
+
+
+### Entry point main app
+``` python
+# main.py
+import asyncio
+from logging_config import setup_logging
+from api.kafka.lifespan import app
+
+if __name__ == "__main__":
+    setup_logging()
+    asyncio.run(app.run())
+```
+
+

fastkafka2-0.1.0/fastkafka/__init__.py

@@ -0,0 +1,19 @@
+__version__ = "0.1.0"
+
+from .logging_utils import suppress_external_logs
+from .app import KafkaApp
+from .handler import KafkaHandler
+from .message import KafkaMessage
+from .producer import KafkaProducer
+
+suppress_external_logs()
+
+__all__ = ["KafkaApp", "KafkaHandler", "KafkaMessage", "KafkaProducer"]
+
+def __getattr__(name: str):
+    if name in __all__:
+        return globals()[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name}")
+
+def __dir__():
+    return __all__ + [n for n in globals() if n.startswith("_")]

fastkafka2-0.1.0/fastkafka/admin.py

@@ -0,0 +1,47 @@
+# fastkafka\admin.py
+import logging
+from aiokafka.admin import AIOKafkaAdminClient, NewTopic
+from aiokafka.errors import TopicAlreadyExistsError
+from .services.base import BaseKafkaService
+from .services.retry import retry_on_connection
+
+logger = logging.getLogger(__name__)
+
+
+class KafkaAdminService(BaseKafkaService):
+    def __init__(self, bootstrap_servers: str = "localhost:9092") -> None:
+        self._bootstrap = bootstrap_servers
+        self._client: AIOKafkaAdminClient | None = None
+
+    async def start(self) -> None:
+        await self._start()
+
+    async def stop(self) -> None:
+        await self._stop()
+
+    @retry_on_connection()
+    async def _start(self) -> None:
+        self._client = AIOKafkaAdminClient(bootstrap_servers=self._bootstrap)
+        await self._client.start()
+        logger.info("KafkaAdminService started")
+
+    async def create_topic(self, topic: str) -> None:
+        if not self._client:
+            raise RuntimeError("Admin client not initialized")
+        try:
+            await self._client.create_topics(
+                new_topics=[
+                    NewTopic(name=topic, num_partitions=1, replication_factor=1)
+                ]
+            )
+            logger.info("Topic created: %s", topic)
+        except TopicAlreadyExistsError:
+            logger.debug("Topic already exists: %s", topic)
+        except Exception:
+            logger.exception("Error creating topic %s", topic)
+            raise
+
+    async def _stop(self) -> None:
+        if self._client:
+            await self._client.close()
+            logger.info("KafkaAdminService stopped")

fastkafka2-0.1.0/fastkafka/app.py

@@ -0,0 +1,79 @@
+# fastkafka\app.py
+import asyncio
+import logging
+import signal
+from typing import Callable
+from contextlib import AbstractAsyncContextManager
+
+from .producer import KafkaProducer
+from .admin import KafkaAdminService
+from .consumer import KafkaConsumerService
+from .registry import handlers_registry
+from .handler import KafkaHandler
+
+logger = logging.getLogger(__name__)
+
+
+class KafkaApp:
+    def __init__(
+        self,
+        title: str,
+        description: str,
+        bootstrap_servers: str = "localhost:9092",
+        lifespan: Callable[["KafkaApp"], AbstractAsyncContextManager] | None = None,
+    ) -> None:
+        self.title = title
+        self.description = description
+        self.bootstrap = bootstrap_servers
+        self._lifespan = lifespan(self) if lifespan else None
+
+        self._producer = KafkaProducer(self.bootstrap)
+        self._admin = KafkaAdminService(self.bootstrap)
+        self._consumer: KafkaConsumerService | None = None
+        self._groups: list[KafkaHandler] = []
+
+    def include_handler(self, handler: KafkaHandler) -> None:
+        self._groups.append(handler)
+        logger.debug("Included handler group %s", handler.prefix)
+
+    async def start(self) -> None:
+        logger.info("Starting %s", self.title)
+        try:
+            if self._lifespan:
+                await self._lifespan.__aenter__()
+            await self._admin.start()
+            for topic in handlers_registry:
+                await self._admin.create_topic(topic)
+            self._consumer = KafkaConsumerService(
+                topics=list(handlers_registry), bootstrap_servers=self.bootstrap
+            )
+            await self._consumer.start()
+            logger.info("%s started", self.title)
+        except Exception:
+            logger.exception("KafkaApp.start failed")
+            raise
+
+    async def stop(self) -> None:
+        logger.info("Stopping %s", self.title)
+        try:
+            if self._consumer:
+                await self._consumer.stop()
+            await self._admin.stop()
+            if self._lifespan:
+                await self._lifespan.__aexit__(None, None, None)
+            logger.info("%s stopped", self.title)
+        except Exception:
+            logger.exception("KafkaApp.stop failed")
+            raise
+
+    async def run(self) -> None:
+        loop = asyncio.get_running_loop()
+        shutdown_event = asyncio.Event()
+        try:
+            for sig in (signal.SIGINT, signal.SIGTERM):
+                loop.add_signal_handler(sig, shutdown_event.set)
+        except (NotImplementedError, AttributeError):
+            signal.signal(signal.SIGINT, lambda *_: shutdown_event.set())
+        await self.start()
+        await shutdown_event.wait()
+        await self.stop()

fastkafka2-0.1.0/fastkafka/consumer.py

@@ -0,0 +1,87 @@
+# fastkafka\consumer.py
+import asyncio
+import orjson
+import logging
+from aiokafka import AIOKafkaConsumer
+from .services.base import BaseKafkaService
+from .registry import handlers_registry
+
+logger = logging.getLogger(__name__)
+
+
+class KafkaConsumerService(BaseKafkaService):
+    def __init__(
+        self,
+        topics: list[str],
+        bootstrap_servers: str,
+        worker_count: int = 4,
+        max_concurrency: int = 100,
+    ):
+        self._topics = topics
+        self._bootstrap = bootstrap_servers
+        self._worker_count = worker_count
+        self._consumer: AIOKafkaConsumer | None = None
+        self._queue: asyncio.Queue = asyncio.Queue(maxsize=1000)
+        self._workers: list[asyncio.Task] = []
+        self._semaphore = asyncio.Semaphore(max_concurrency)
+        self._metrics_task: asyncio.Task | None = None
+
+    async def start(self) -> None:
+        self._consumer = AIOKafkaConsumer(
+            *self._topics,
+            bootstrap_servers=self._bootstrap,
+            group_id="fastkafka_group",
+            auto_offset_reset="latest",
+            value_deserializer=lambda v: orjson.loads(v),
+        )
+        await self._consumer.start()
+        logger.info("KafkaConsumerService started on topics %s", self._topics)
+
+        asyncio.create_task(self._consume_loop())
+        self._workers = [
+            asyncio.create_task(self._worker_loop()) for _ in range(self._worker_count)
+        ]
+        self._metrics_task = asyncio.create_task(self._metrics_loop())
+
+    async def stop(self) -> None:
+        if self._consumer:
+            await self._consumer.stop()
+            logger.info("Consumer stopped")
+        for w in self._workers:
+            w.cancel()
+        await asyncio.gather(*self._workers, return_exceptions=True)
+        if self._metrics_task:
+            self._metrics_task.cancel()
+            await asyncio.gather(self._metrics_task, return_exceptions=True)
+
+    async def _consume_loop(self) -> None:
+        try:
+            async for msg in self._consumer:
+                headers = {k: (v.decode() if v else "") for k, v in (msg.headers or [])}
+                key = msg.key.decode() if msg.key else None
+                await self._queue.put((msg.topic, msg.value, headers, key))
+        except Exception:
+            logger.exception("Error in consume loop")
+
+    async def _worker_loop(self) -> None:
+        while True:
+            topic, data, headers, key = await self._queue.get()
+            for handler in handlers_registry.get(topic, []):
+                await self._semaphore.acquire()
+                asyncio.create_task(self._safe_invoke(handler, data, headers, key))
+            self._queue.task_done()
+
+    async def _safe_invoke(self, handler, data, headers, key):
+        try:
+            await handler.handle(data, headers, key)
+        except Exception as e:
+            logger.warning("Handler error on topic %s: %s", handler.topic, e)
+        finally:
+            self._semaphore.release()
+
+    async def _metrics_loop(self):
+        while True:
+            logger.debug(
+                f"[Kafka] Queue size: {self._queue.qsize()} | Workers: {len(self._workers)}"
+            )
+            await asyncio.sleep(10)

fastkafka2-0.1.0/fastkafka/dependencies.py

@@ -0,0 +1,36 @@
+# fastkafka\dependencies.py
+import logging
+from .admin import KafkaAdminService
+from .consumer import KafkaConsumerService
+from .registry import handlers_registry
+
+logger = logging.getLogger(__name__)
+_admin = KafkaAdminService()
+_consumer: KafkaConsumerService | None = None
+
+
+async def start_kafka(bootstrap_servers: str) -> None:
+    global _consumer
+    try:
+        await _admin.start()
+        for topic in handlers_registry:
+            await _admin.create_topic(topic)
+        _consumer = KafkaConsumerService(
+            topics=list(handlers_registry), bootstrap_servers=bootstrap_servers
+        )
+        await _consumer.start()
+        logger.info("Dependencies started")
+    except Exception:
+        logger.exception("Failed to start Kafka dependencies")
+        raise
+
+
+async def stop_kafka() -> None:
+    try:
+        if _consumer:
+            await _consumer.stop()
+        await _admin.stop()
+        logger.info("Dependencies stopped")
+    except Exception:
+        logger.exception("Failed to stop Kafka dependencies")
+        raise

fastkafka2-0.1.0/fastkafka/di/__init__.py

@@ -0,0 +1 @@
+# fastkafka\di\__init__.py

fastkafka2-0.1.0/fastkafka/di/di_container.py

@@ -0,0 +1,43 @@
+# fastkafka\di\di_container.py
+import logging
+from inspect import isclass, signature
+from typing import Any, Callable, Type
+
+logger = logging.getLogger(__name__)
+
+_singletons: dict[Type[Any], Any] = {}
+_factories: dict[Type[Any], Callable[..., Any]] = {}
+_resolving_stack: set[Type[Any]] = set()
+_sig_cache: dict[Type[Any], Any] = {}
+
+
+def register_singleton(cls: Type[Any], instance: Any) -> None:
+    _singletons[cls] = instance
+
+
+def register_factory(cls: Type[Any], factory: Callable[..., Any]) -> None:
+    _factories[cls] = factory
+
+
+def resolve(cls: Type[Any]) -> Any:
+    if cls in _singletons:
+        return _singletons[cls]
+    if cls in _factories:
+        return _factories[cls]()
+    if not isclass(cls):
+        raise TypeError(f"Cannot resolve non-class type: {cls}")
+    if cls in _resolving_stack:
+        raise RuntimeError(f"Circular dependency detected: {cls.__name__}")
+
+    _resolving_stack.add(cls)
+    try:
+        sig = _sig_cache.get(cls) or signature(cls.__init__)
+        _sig_cache[cls] = sig
+        kwargs = {
+            name: resolve(param.annotation)
+            for name, param in sig.parameters.items()
+            if name != "self"
+        }
+        return cls(**kwargs)
+    finally:
+        _resolving_stack.remove(cls)

fastkafka2-0.1.0/fastkafka/handler.py

@@ -0,0 +1,19 @@
+# fastkafka\handler.py
+import logging
+from typing import Callable, Any
+from .registry import kafka_handler
+
+logger = logging.getLogger(__name__)
+
+
+class KafkaHandler:
+    def __init__(self, prefix: str = "") -> None:
+        self.prefix = prefix
+
+    def __call__(
+        self, topic: str, data_model: Any = None
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        return kafka_handler(topic, data_model)
+
+    def include_handler(self, other: "KafkaHandler") -> None:
+        self.prefix += f".{other.prefix}" if other.prefix else ""

fastkafka2-0.1.0/fastkafka/logging_utils.py

@@ -0,0 +1,19 @@
+# fastkafka\logging_utils.py
+import logging
+
+
+def suppress_external_logs() -> None:
+    suppressed = [
+        "aiokafka",
+        "kafka",
+        "asyncio",
+        "aiokafka.consumer.fetcher",
+        "aiokafka.cluster",
+        "aiokafka.producer.producer",
+        "aiokafka.consumer.group_coordinator",
+        "aiokafka.consumer.subscription_state",
+    ]
+    for name in suppressed:
+        lg = logging.getLogger(name)
+        lg.setLevel(logging.CRITICAL)
+        lg.propagate = False

fastkafka2-0.1.0/fastkafka/message.py

@@ -0,0 +1,11 @@
+# fastkafka\message.py
+from pydantic import BaseModel
+
+
+class KafkaMessage(BaseModel):
+    topic: str
+    data: object
+    headers: dict[str, str] = {}
+    key: str | None = None
+
+    model_config = {"extra": "forbid", "frozen": True, "slots": True}

fastkafka2-0.1.0/fastkafka/producer.py

@@ -0,0 +1,57 @@
+# fastkafka\producer.py
+import orjson
+import logging
+from typing import Any
+from aiokafka import AIOKafkaProducer
+from .services.base import BaseKafkaService
+from .services.retry import retry_on_connection
+
+logger = logging.getLogger(__name__)
+
+
+def _serialize_headers(headers: dict[str, str]) -> list[tuple[str, bytes]]:
+    return [(k, v.encode()) for k, v in headers.items()]
+
+
+class KafkaProducer(BaseKafkaService):
+    def __init__(self, bootstrap_servers: str) -> None:
+        self.bootstrap_servers = bootstrap_servers
+        self._producer: AIOKafkaProducer | None = None
+
+    @retry_on_connection()
+    async def start(self) -> None:
+        self._producer = AIOKafkaProducer(
+            bootstrap_servers=self.bootstrap_servers,
+            value_serializer=lambda v: orjson.dumps(v),
+        )
+        await self._producer.start()
+        logger.info("KafkaProducer started")
+
+    @retry_on_connection()
+    async def send_message(
+        self,
+        topic: str,
+        data: dict[str, Any],
+        headers: dict[str, str] | None = None,
+        key: str | None = None,
+    ) -> None:
+        if not self._producer:
+            raise RuntimeError("Producer not started")
+        try:
+            kafka_headers = _serialize_headers(headers or {})
+            key_bytes = key.encode() if key else None
+            await self._producer.send_and_wait(
+                topic=topic,
+                value=data,
+                headers=kafka_headers,
+                key=key_bytes,
+            )
+        except Exception:
+            logger.exception("Failed to send message")
+            raise
+
+    async def stop(self) -> None:
+        if self._producer:
+            await self._producer.flush()
+            await self._producer.stop()
+            logger.info("KafkaProducer stopped")

fastkafka2-0.1.0/fastkafka/registry.py

@@ -0,0 +1,61 @@
+# fastkafka\registry.py
+import logging
+from inspect import signature, iscoroutinefunction
+from typing import Any, Callable
+from pydantic import BaseModel
+from fastkafka.message import KafkaMessage
+from fastkafka.di.di_container import resolve
+
+__all__ = ["kafka_handler"]
+
+logger = logging.getLogger(__name__)
+handlers_registry: dict[str, list["CompiledHandler"]] = {}
+
+
+class CompiledHandler:
+    __slots__ = ("topic", "func", "sig", "data_model", "dependencies")
+
+    def __init__(
+        self, topic: str, func: Callable[..., Any], data_model: type[BaseModel] | None
+    ):
+        self.topic = topic
+        self.func = func
+        self.sig = signature(func)
+        self.data_model = data_model
+
+        self.dependencies: dict[str, Any] = {}
+        for name, param in self.sig.parameters.items():
+            if param.annotation not in (KafkaMessage, data_model):
+                self.dependencies[name] = resolve(param.annotation)
+
+    async def handle(
+        self, raw_data: Any, headers: dict[str, str] | None, key: str | None
+    ):
+        msg_data = self.data_model(**raw_data) if self.data_model else raw_data
+        message = KafkaMessage(
+            topic=self.topic, data=msg_data, headers=headers or {}, key=key
+        )
+
+        kwargs = {
+            name: (
+                self.dependencies.get(name)
+                if param.annotation not in (KafkaMessage, self.data_model)
+                else message
+            )
+            for name, param in self.sig.parameters.items()
+        }
+
+        return await self.func(**kwargs)
+
+
+def kafka_handler(topic: str, data_model: type[BaseModel] | None = None):
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        if not iscoroutinefunction(func):
+            raise TypeError("Handler must be async")
+        handlers_registry.setdefault(topic, []).append(
+            CompiledHandler(topic, func, data_model)
+        )
+        logger.debug("Registered handler %s for topic %s", func.__name__, topic)
+        return func
+
+    return decorator

fastkafka2-0.1.0/fastkafka/services/__init__.py

@@ -0,0 +1 @@
+# fastkafka\services\__init__.py

fastkafka2-0.1.0/fastkafka/services/base.py

@@ -0,0 +1,12 @@
+# fastkafka\services\base.py
+from abc import ABC, abstractmethod
+
+__all__ = ["BaseKafkaService"]
+
+
+class BaseKafkaService(ABC):
+    @abstractmethod
+    async def start(self) -> None: ...
+
+    @abstractmethod
+    async def stop(self) -> None: ...

fastkafka2-0.1.0/fastkafka/services/retry.py

@@ -0,0 +1,27 @@
+# fastkafka\services\retry.py
+import asyncio
+import logging
+from aiokafka.errors import KafkaConnectionError
+from typing import Callable, TypeVar, Awaitable
+
+__all__ = ["retry_on_connection"]
+
+Logger = logging.getLogger(__name__)
+F = TypeVar("F", bound=Callable[..., Awaitable[None]])
+
+
+def retry_on_connection(delay: int = 5) -> Callable[[F], F]:
+    def decorator(fn: F) -> F:
+        async def wrapper(*args, **kwargs):
+            while True:
+                try:
+                    return await fn(*args, **kwargs)
+                except KafkaConnectionError as e:
+                    Logger.warning(
+                        "Retrying %s due to connection error: %s", fn.__name__, e
+                    )
+                    await asyncio.sleep(delay)
+
+        return wrapper  # type: ignore
+
+    return decorator

fastkafka2-0.1.0/fastkafka2.egg-info/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: fastkafka2
+Version: 0.1.0
+Summary: Next-generation FastAPI-like DX for Kafka (version 2)
+Author: Ruslan Ramazanov
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.6
+Requires-Dist: anyio>=4
+Requires-Dist: aiokafka>=0.10
+Requires-Dist: typing-extensions>=4.8
+
+# fastkafka2
+
+Next-generation FastAPI-like DX for Kafka (version 2).
+
+## Installation
+
+``` bash
+pip install fastkafka2
+```
+
+## Use example
+### Project arch
+```shell
+├── api/
+│   ├── kafka/
+│   │   ├── handlers/
+│   │   │   ├── example/
+│   │   │   │   ├─ schemas.py
+│   │   │   │   └─ handler.py
+│   │   │   └── base_handler.py
+│   │   └── lifespan.py
+│
+├── main.py
+```
+
+### Schemas
+``` python
+# api\kafka\handlers\example\schemas.py
+from pydantic import BaseModel
+
+
+class ExampleSchema(BaseModel):
+    msg: str
+```
+
+### Handler
+``` python
+# api\kafka\handlers\example\handler.py
+import logging
+
+from fastkafka.handler import KafkaHandler
+from fastkafka.message import KafkaMessage
+from fastkafka.producer import KafkaProducer
+
+
+handler = KafkaHandler()
+
+kafka_producer = KafkaProducer(bootstrap_servers="127.0.0.1:9092")
+
+
+@handler("example")
+async def example_handler(message: KafkaMessage):
+    t = int(message.headers.get("try")) + 1
+    logging.info(f"Пришло: {message}")
+    await kafka_producer.send_message(
+        topic="example-2", data={"msg": "wddwd"}, headers={"try": f"{t}"}, key=None
+    )
+    logging.info(f"Отправил: {f'{t}'}")
+```
+
+
+### Grouping of handlers
+``` python
+# api\kafka\handlers\base_handler.py
+from api.kafka.handlers.example.handler import handler as example_handler
+
+from fastkafka.handler import KafkaHandler
+
+base_handler = KafkaHandler()
+
+base_handler.include_handler(example_handler)
+```
+
+
+### Lifespan fastkafka app
+``` python
+# api/kafka/lifespan.py
+import logging
+from contextlib import asynccontextmanager
+from fastkafka.app import KafkaApp
+from api.kafka.handlers.base_handler import base_handler
+
+from api.kafka.handlers.example.handler import kafka_producer
+
+
+@asynccontextmanager
+async def lifespan(app: KafkaApp):
+    logging.info("Lifespan: запуск")
+    try:
+        await kafka_producer.start()
+        yield
+        logging.info("Lifespan: выполнен")
+    finally:
+        await kafka_producer.stop()
+        logging.info("Lifespan: остановка")
+
+
+app = KafkaApp(
+    title="Kafka Gateway",
+    description="Kafka-based microservice",
+    bootstrap_servers="127.0.0.1:9092",
+    lifespan=lifespan,
+)
+
+app.include_handler(base_handler)
+```
+
+
+### Entry point main app
+``` python
+# main.py
+import asyncio
+from logging_config import setup_logging
+from api.kafka.lifespan import app
+
+if __name__ == "__main__":
+    setup_logging()
+    asyncio.run(app.run())
+```
+
+

fastkafka2-0.1.0/fastkafka2.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+fastkafka/__init__.py
+fastkafka/admin.py
+fastkafka/app.py
+fastkafka/consumer.py
+fastkafka/dependencies.py
+fastkafka/handler.py
+fastkafka/logging_utils.py
+fastkafka/message.py
+fastkafka/producer.py
+fastkafka/py.typed
+fastkafka/registry.py
+fastkafka2.egg-info/PKG-INFO
+fastkafka2.egg-info/SOURCES.txt
+fastkafka2.egg-info/dependency_links.txt
+fastkafka2.egg-info/requires.txt
+fastkafka2.egg-info/top_level.txt
+fastkafka/di/__init__.py
+fastkafka/di/di_container.py
+fastkafka/services/__init__.py
+fastkafka/services/base.py
+fastkafka/services/retry.py

fastkafka2-0.1.0/fastkafka2.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fastkafka2-0.1.0/fastkafka2.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pydantic>=2.6
+anyio>=4
+aiokafka>=0.10
+typing-extensions>=4.8

fastkafka2-0.1.0/fastkafka2.egg-info/top_level.txt

@@ -0,0 +1 @@
+fastkafka

fastkafka2-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastkafka2"
+version = "0.1.0"
+description = "Next-generation FastAPI-like DX for Kafka (version 2)"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+  { name = "Ruslan Ramazanov" }
+]
+dependencies = [
+  "pydantic>=2.6",
+  "anyio>=4",
+  "aiokafka>=0.10",
+  "typing-extensions>=4.8",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["fastkafka*"]

fastkafka2-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+