jararaca 0.2.37a10__py3-none-any.whl → 0.2.37a12__py3-none-any.whl

jararaca/__init__.py

@@ -59,6 +59,7 @@ if TYPE_CHECKING:
     from .messagebus.decorators import MessageBusController, MessageHandler
     from .messagebus.interceptors.aiopika_publisher_interceptor import (
         AIOPikaConnectionFactory,
+        GenericPoolConfig,
         MessageBusPublisherInterceptor,
     )
     from .messagebus.publisher import use_publisher
@@ -192,6 +193,7 @@ if TYPE_CHECKING:
         "Put",
         "Delete",
         "use_publisher",
+        "GenericPoolConfig",
         "AIOPikaConnectionFactory",
         "MessageBusPublisherInterceptor",
         "RedisWebSocketConnectionBackend",
@@ -221,6 +223,11 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
         "messagebus.bus_message_controller",
         None,
     ),
+    "GenericPoolConfig": (
+        __SPEC_PARENT__,
+        "messagebus.interceptors.aiopika_publisher_interceptor",
+        None,
+    ),
     "ack": (__SPEC_PARENT__, "messagebus.bus_message_controller", None),
     "nack": (__SPEC_PARENT__, "messagebus.bus_message_controller", None),
     "reject": (__SPEC_PARENT__, "messagebus.bus_message_controller", None),

jararaca/cli.py

@@ -1,5 +1,8 @@
 import importlib
 import importlib.resources
+import os
+import sys
+import time
 from codecs import StreamWriter
 from typing import Any
 from urllib.parse import urlparse, urlunsplit
@@ -208,12 +211,83 @@ def scheduler(
     "file_path",
     type=click.File("w"),
 )
-def gen_tsi(app_path: str, file_path: StreamWriter) -> None:
-    app = find_microservice_by_module_path(app_path)
+@click.option(
+    "--watch",
+    is_flag=True,
+    help="Watch for file changes and regenerate TypeScript interfaces",
+)
+@click.option(
+    "--src-dir",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    default="src",
+    help="Source directory to watch for changes (default: src)",
+)
+def gen_tsi(app_path: str, file_path: StreamWriter, watch: bool, src_dir: str) -> None:
+    """Generate TypeScript interfaces from a Python microservice."""
+
+    # Generate typescript interfaces
+    def generate_interfaces() -> None:
+        try:
+            app = find_microservice_by_module_path(app_path)
+            content = write_microservice_to_typescript_interface(app)
+
+            # Save current position
+            file_path.tell()
+
+            # Reset file to beginning
+            file_path.seek(0)
+            file_path.truncate()
+
+            # Write new content
+            file_path.write(content)
+            file_path.flush()
 
-    content = write_microservice_to_typescript_interface(app)
+            print(f"Generated TypeScript interfaces at {time.strftime('%H:%M:%S')}")
+        except Exception as e:
+            print(f"Error generating TypeScript interfaces: {e}", file=sys.stderr)
 
-    file_path.write(content)
+    # Initial generation
+    generate_interfaces()
+
+    # If watch mode is not enabled, exit
+    if not watch:
+        return
+
+    try:
+        from watchdog.events import FileSystemEvent, FileSystemEventHandler
+        from watchdog.observers import Observer
+    except ImportError:
+        print(
+            "Watchdog is required for watch mode. Install it with: pip install watchdog",
+            file=sys.stderr,
+        )
+        return
+
+    # Set up file system event handler
+    class PyFileChangeHandler(FileSystemEventHandler):
+        def on_modified(self, event: FileSystemEvent) -> None:
+            src_path = (
+                event.src_path
+                if isinstance(event.src_path, str)
+                else str(event.src_path)
+            )
+            if not event.is_directory and src_path.endswith(".py"):
+                print(f"File changed: {src_path}")
+                generate_interfaces()
+
+    # Set up observer
+    observer = Observer()
+    observer.schedule(PyFileChangeHandler(), src_dir, recursive=True)
+    observer.start()
+
+    print(f"Watching for changes in {os.path.abspath(src_dir)}...")
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+        print("Watch mode stopped")
+    observer.join()
 
 
 def camel_case_to_snake_case(name: str) -> str:

jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py

@@ -2,6 +2,7 @@ from contextlib import asynccontextmanager
 from typing import Any, AsyncContextManager, AsyncGenerator, Protocol
 
 import aio_pika
+from aio_pika.abc import AbstractConnection
 from pydantic import BaseModel
 
 from jararaca.messagebus.publisher import MessagePublisher, provide_message_publisher
@@ -25,6 +26,10 @@ class MessageBusPublisherInterceptor(AppInterceptor):
 
     @asynccontextmanager
     async def intercept(self, app_context: AppContext) -> AsyncGenerator[None, None]:
+        if app_context.context_type == "websocket":
+            yield
+            return
+
         async with self.connection_factory.provide_connection() as connection:
             with provide_message_publisher(self.connection_name, connection):
                 yield
@@ -48,29 +53,79 @@ class AIOPikaMessagePublisher(MessagePublisher):
         )
 
 
+class GenericPoolConfig(BaseModel):
+    max_size: int
+
+
 class AIOPikaConnectionFactory(MessageBusConnectionFactory):
 
     def __init__(
         self,
         url: str,
         exchange: str,
+        connection_pool_config: GenericPoolConfig | None = None,
+        channel_pool_config: GenericPoolConfig | None = None,
     ):
         self.url = url
         self.exchange = exchange
 
+        self.connection_pool: aio_pika.pool.Pool[AbstractConnection] | None = None
+        self.channel_pool: aio_pika.pool.Pool[aio_pika.abc.AbstractChannel] | None = (
+            None
+        )
+
+        if connection_pool_config:
+
+            async def get_connection() -> AbstractConnection:
+                return await aio_pika.connect_robust(self.url)
+
+            self.connection_pool = aio_pika.pool.Pool[AbstractConnection](
+                get_connection,
+                max_size=connection_pool_config.max_size,
+            )
+
+        if channel_pool_config:
+
+            async def get_channel() -> aio_pika.abc.AbstractChannel:
+                async with self.acquire_connection() as connection:
+                    return await connection.channel(publisher_confirms=False)
+
+            self.channel_pool = aio_pika.pool.Pool[aio_pika.abc.AbstractChannel](
+                get_channel, max_size=channel_pool_config.max_size
+            )
+
+    @asynccontextmanager
+    async def acquire_connection(self) -> AsyncGenerator[AbstractConnection, Any]:
+        if not self.connection_pool:
+            async with await aio_pika.connect_robust(self.url) as connection:
+                yield connection
+        else:
+
+            async with self.connection_pool.acquire() as connection:
+                yield connection
+
+    @asynccontextmanager
+    async def acquire_channel(
+        self,
+    ) -> AsyncGenerator[aio_pika.abc.AbstractChannel, Any]:
+        if not self.channel_pool:
+            async with self.acquire_connection() as connection:
+                yield await connection.channel(publisher_confirms=False)
+        else:
+            async with self.channel_pool.acquire() as channel:
+                yield channel
+
     @asynccontextmanager
     async def provide_connection(self) -> AsyncGenerator[AIOPikaMessagePublisher, Any]:
-        connection = await aio_pika.connect_robust(self.url)
-        async with connection:
-            async with connection.channel(publisher_confirms=False) as channel:
 
-                tx = channel.transaction()
+        async with self.acquire_channel() as channel:
+            tx = channel.transaction()
 
-                await tx.select()
+            await tx.select()
 
-                try:
-                    yield AIOPikaMessagePublisher(channel, exchange_name=self.exchange)
-                    await tx.commit()
-                except Exception as e:
-                    await tx.rollback()
-                    raise e
+            try:
+                yield AIOPikaMessagePublisher(channel, exchange_name=self.exchange)
+                await tx.commit()
+            except Exception as e:
+                await tx.rollback()
+                raise e

jararaca/messagebus/worker.py

@@ -205,17 +205,17 @@ class MessageHandlerCallback:
         self, aio_pika_message: aio_pika.abc.AbstractIncomingMessage
     ) -> None:
 
-        rounting_key = self.queue_name
+        routing_key = self.queue_name
 
-        if rounting_key is None:
+        if routing_key is None:
             logger.warning("No topic found for message")
             await self.handle_reject_message(aio_pika_message)
             return
 
-        handler_data = self.consumer.incoming_map.get(rounting_key)
+        handler_data = self.consumer.incoming_map.get(routing_key)
 
         if handler_data is None:
-            logger.warning("No handler found for topic '%s'" % rounting_key)
+            logger.warning("No handler found for topic '%s'" % routing_key)
             await self.handle_reject_message(aio_pika_message)
 
             return
@@ -227,7 +227,7 @@ class MessageHandlerCallback:
         if len(sig.parameters) != 1:
             logger.warning(
                 "Handler for topic '%s' must have exactly one parameter which is MessageOf[T extends Message]"
-                % rounting_key
+                % routing_key
             )
             return
 
@@ -238,14 +238,14 @@ class MessageHandlerCallback:
         if param_origin is not MessageOf:
             logger.warning(
                 "Handler for topic '%s' must have exactly one parameter of type Message"
-                % rounting_key
+                % routing_key
             )
             return
 
         if len(parameter.annotation.__args__) != 1:
             logger.warning(
                 "Handler for topic '%s' must have exactly one parameter of type Message"
-                % rounting_key
+                % routing_key
             )
             return
 
@@ -253,8 +253,8 @@ class MessageHandlerCallback:
 
         if not issubclass(message_type, BaseModel):
             logger.warning(
-                "Handler for topic '%s' must have exactly one parameter of type Message[BaseModel]"
-                % rounting_key
+                "Handler for topic '%s' must have exactly one parameter of type MessageOf[BaseModel]"
+                % routing_key
             )
             return
 
@@ -266,7 +266,7 @@ class MessageHandlerCallback:
         async with self.consumer.uow_context_provider(
             MessageBusAppContext(
                 message=builded_message,
-                topic=rounting_key,
+                topic=routing_key,
             )
         ):
             ctx: AsyncContextManager[Any]
@@ -293,7 +293,7 @@ class MessageHandlerCallback:
                             )
                     else:
                         logger.exception(
-                            f"Error processing message on topic {rounting_key}"
+                            f"Error processing message on topic {routing_key}"
                         )
                     if incoming_message_spec.requeue_on_exception:
                         await self.handle_reject_message(aio_pika_message, requeue=True)

jararaca-0.2.37a12.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.3
+Name: jararaca
+Version: 0.2.37a12
+Summary: A simple and fast API framework for Python
+Author: Lucas S
+Author-email: me@luscasleo.dev
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: docs
+Provides-Extra: http
+Provides-Extra: opentelemetry
+Requires-Dist: aio-pika (>=9.4.3,<10.0.0)
+Requires-Dist: croniter (>=3.0.3,<4.0.0)
+Requires-Dist: fastapi (>=0.113.0,<0.114.0)
+Requires-Dist: mako (>=1.3.5,<2.0.0)
+Requires-Dist: opentelemetry-api (>=1.27.0,<2.0.0) ; extra == "opentelemetry"
+Requires-Dist: opentelemetry-distro (>=0.49b2,<0.50) ; extra == "opentelemetry"
+Requires-Dist: opentelemetry-exporter-otlp (>=1.27.0,<2.0.0) ; extra == "opentelemetry"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.27.0,<2.0.0) ; extra == "opentelemetry"
+Requires-Dist: opentelemetry-sdk (>=1.27.0,<2.0.0) ; extra == "opentelemetry"
+Requires-Dist: redis (>=5.0.8,<6.0.0)
+Requires-Dist: sqlalchemy (>=2.0.34,<3.0.0)
+Requires-Dist: types-croniter (>=3.0.3.20240731,<4.0.0.0)
+Requires-Dist: types-redis (>=4.6.0.20240903,<5.0.0.0)
+Requires-Dist: uvicorn (>=0.30.6,<0.31.0)
+Requires-Dist: uvloop (>=0.20.0,<0.21.0)
+Requires-Dist: websockets (>=13.0.1,<14.0.0)
+Project-URL: Repository, https://github.com/LuscasLeo/jararaca
+Description-Content-Type: text/markdown
+
+<img src="https://raw.githubusercontent.com/LuscasLeo/jararaca/main/docs/assets/_f04774c9-7e05-4da4-8b17-8be23f6a1475.jpeg" alt="Jararaca Logo" width="250" float="right">
+
+# Jararaca Microservice Framework
+
+## Overview
+
+Jararaca is an async-first microservice framework designed to simplify the development of distributed systems. It provides a comprehensive set of tools for building robust, scalable, and maintainable microservices with a focus on developer experience and type safety.
+
+## Key Features
+
+### REST API Development
+- Easy-to-use interfaces for building REST APIs
+- Automatic request/response validation
+- Type-safe endpoints with FastAPI integration
+- Automatic OpenAPI documentation generation
+
+### Message Bus Integration
+- Topic-based message bus for event-driven architecture
+- Support for both worker and publisher patterns
+- Built-in message serialization and deserialization
+- Easy integration with AIO Pika for RabbitMQ
+
+### Distributed WebSocket
+- Room-based WebSocket communication
+- Distributed broadcasting across multiple backend instances
+- Automatic message synchronization between instances
+- Built-in connection management and room handling
+
+### Task Scheduling
+- Cron-based task scheduling
+- Support for overlapping and non-overlapping tasks
+- Distributed task execution
+- Easy integration with message bus for task distribution
+
+### TypeScript Integration
+- Automatic TypeScript interface generation
+- Command-line tool for generating TypeScript types
+- Support for REST endpoints, WebSocket events, and message bus payloads
+- Type-safe frontend-backend communication
+
+### Hexagonal Architecture
+- Clear separation of concerns
+- Business logic isolation from infrastructure
+- Easy testing and maintainability
+- Dependency injection for flexible component management
+
+### Observability
+- Built-in OpenTelemetry integration
+- Distributed tracing support
+- Logging and metrics collection
+- Performance monitoring capabilities
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install jararaca
+```
+
+### Basic Usage
+
+```python
+from jararaca import Microservice, create_http_server
+from jararaca.presentation.http_microservice import HttpMicroservice
+
+# Define your microservice
+app = Microservice(
+    providers=[
+        # Add your providers here
+    ],
+    controllers=[
+        # Add your controllers here
+    ],
+    interceptors=[
+        # Add your interceptors here
+    ],
+)
+
+# Create HTTP server
+http_app = HttpMicroservice(app)
+web_app = create_http_server(app)
+```
+
+### Running the Service
+
+```bash
+# Run as HTTP server
+jararaca server app:http_app
+
+# Run as message bus worker
+jararaca worker app:app
+
+# Run as scheduler
+jararaca scheduler app:app
+
+# Generate TypeScript interfaces
+jararaca gen-tsi app.main:app app.ts
+```
+
+## Documentation
+
+For detailed documentation, please visit our [documentation site](https://luscasleo.github.io/jararaca/).
+
+## Examples
+
+Check out the [examples directory](examples/) for complete working examples of:
+- REST API implementation
+- WebSocket usage
+- Message bus integration
+- Task scheduling
+- TypeScript interface generation
+
+## Contributing
+
+Contributions are welcome! Please read our [contributing guidelines](.github/CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+

{jararaca-0.2.37a10.dist-info → jararaca-0.2.37a12.dist-info}/RECORD

@@ -1,9 +1,6 @@
-LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-README.md,sha256=mte30I-ZEJJp-Oax-OganNgl6G9GaCZPL6JVFAvZGz4,7034
-pyproject.toml,sha256=Hz6Rk-E8INfd6U7oblRlcW8Qvm_aRmyY_EjWaGj6ukw,1840
-jararaca/__init__.py,sha256=gDCvrIhIu5_IkKjmZmhWZ2khOi8WGiw2AidFFe-BnWU,15118
+jararaca/__init__.py,sha256=VBrN25GHJ3gDG95CcJWe3dmGcA-X2agzOCIBbjzc1Iw,15312
 jararaca/__main__.py,sha256=-O3vsB5lHdqNFjUtoELDF81IYFtR-DSiiFMzRaiSsv4,67
-jararaca/cli.py,sha256=JKk4xrRbtX2fM8yYw794lbxvJFH73bWw3GGIvrpAkeE,5706
+jararaca/cli.py,sha256=K6df8fqEc4Qj-yGz5hmO3pSgFWxcLP4iciOP4LHida4,7979
 jararaca/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/core/providers.py,sha256=wktH84FK7c1s2wNq-fudf1uMfi3CQBR0neU2czJ_L0U,434
@@ -15,10 +12,10 @@ jararaca/messagebus/__init__.py,sha256=Zdl74HcS9K0FW6XUt7bVvaHEyxL8pWsqqakeRENIn
 jararaca/messagebus/bus_message_controller.py,sha256=Xd_qwnX5jUvgBTCarHR36fvtol9lPTsYp2IIGKyQQaE,1487
 jararaca/messagebus/decorators.py,sha256=GHlaXRuHtrz6R0HgcG2gJybpGYtdts9meDVSRPwN74I,4245
 jararaca/messagebus/interceptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py,sha256=rqAX644-VHarg6kPPsXGTmxYd79PpJXiJ1N1gIooJTo,2470
+jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py,sha256=BPH5wOlj_CyHtJ7W4NWF2h0gYMwzOPNzFhGADk618N4,4373
 jararaca/messagebus/publisher.py,sha256=5ay9Znwybqt981OOykdWkFisSvGiTeTpPXDFLMnaiqg,1109
 jararaca/messagebus/types.py,sha256=iYLyLxWqOHkDadxyMqQPWy3itLNQfvD6oQe8jcq9nzo,887
-jararaca/messagebus/worker.py,sha256=hKACTyrIMHcuaySpmI3UhDCja6va1gGkFRoZJ7kYfoA,13613
+jararaca/messagebus/worker.py,sha256=_X2Ctj7bI9XjCMvQMy8jM3dEE3CGnqgrU_B3lTGfmmQ,13605
 jararaca/microservice.py,sha256=1TvDKVMMREH27Ly8eTEheMmSfro4_Az_JKM_NdDvrgc,6636
 jararaca/observability/decorators.py,sha256=XffBinFXdiNkY6eo8_1nkr_GapM0RUGBg0aicBIelag,2220
 jararaca/observability/interceptor.py,sha256=GHkuGKFWftN7MDjvYeGFGEPnuJETNhtxRK6yuPrCrpU,1462
@@ -59,8 +56,8 @@ jararaca/tools/app_config/decorators.py,sha256=-ckkMZ1dswOmECdo1rFrZ15UAku--txaN
 jararaca/tools/app_config/interceptor.py,sha256=nfFZiS80hrbnL7-XEYrwmp2rwaVYBqxvqu3Y-6o_ov4,2575
 jararaca/tools/metadata.py,sha256=7nlCDYgItNybentPSSCc2MLqN7IpBd0VyQzfjfQycVI,1402
 jararaca/tools/typescript/interface_parser.py,sha256=4SHt094P-QawMFHSyMCiujQf8Niw7xACIO1RHBM8-w4,29192
-jararaca-0.2.37a10.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.2.37a10.dist-info/METADATA,sha256=d0angF0OwLZKGkRL3wKp8GkP79k0HTXlfRIUXRAoZOA,8555
-jararaca-0.2.37a10.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-jararaca-0.2.37a10.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.2.37a10.dist-info/RECORD,,
+jararaca-0.2.37a12.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.2.37a12.dist-info/METADATA,sha256=W8aHUpqo5Q5iGBwX0BE4CS9MfEEMN97vM-YRuCJ2URM,4873
+jararaca-0.2.37a12.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+jararaca-0.2.37a12.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.2.37a12.dist-info/RECORD,,

{jararaca-0.2.37a10.dist-info → jararaca-0.2.37a12.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any