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

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/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.37a11.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=6qmtrXrdw7bJZOL_-RGgWJtkCmz7b42Xbc-NwubeGTQ,1840
 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
@@ -18,7 +15,7 @@ jararaca/messagebus/interceptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRk
 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.37a11.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.2.37a11.dist-info/METADATA,sha256=o0sSsRaTx6-ySotULbIhDQtza302CTjxCc9jdAJxbJ8,8555
-jararaca-0.2.37a11.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-jararaca-0.2.37a11.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.2.37a11.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.37a11.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

README.md

@@ -1,243 +0,0 @@
-<img src="https://raw.githubusercontent.com/LuscasLeo/jararaca/main/docs/assets/_f04774c9-7e05-4da4-8b17-8be23f6a1475.jpeg" alt="README.md" width="250" float="right">
-
-# Jararaca Microservice Framework
-
-## Overview
-
-Jararaca is a aio-first microservice framework that provides a set of tools to build and deploy microservices in a simple and clear way.
-
-## Features
-
-### Hexagonal Architecture
-
-The framework is based on the hexagonal architecture, which allows you to separate the business logic from the infrastructure, making the code more testable and maintainable.
-
-### Dependency Injection
-
-The framework uses the dependency injection pattern to manage the dependencies between the components of the application.
-
-```py
-    app = Microservice(
-        providers=[
-            ProviderSpec(
-                provide=Token(AuthConfig, "AUTH_CONFIG"),
-                use_value=AuthConfig(
-                    secret="secret",
-                    identity_refresh_token_expires_delta_seconds=60 * 60 * 24 * 30,
-                    identity_token_expires_delta_seconds=60 * 60,
-                ),
-            ),
-            ProviderSpec(
-                provide=Token(AppConfig, "APP_CONFIG"),
-                use_factory=AppConfig.provider,
-            ),
-            ProviderSpec(
-                provide=TokenBlackListService,
-                use_value=InMemoryTokenBlackListService(),
-            ),
-        ],
-    )
-```
-
-### Web Server Port
-
-The framework provides a web server that listens on a specific port and routes the requests to the appropriate handler. It uses [FastAPI](https://fastapi.tiangolo.com/) as the web framework.
-
-```py
-    @Delete("/{task_id}")
-    async def delete_task(self, task_id: TaskId) -> None:
-        await self.tasks_crud.delete_by_id(task_id)
-
-        await use_ws_manager().broadcast(("Task %s deleted" % task_id).encode())
-```
-
-### Message Bus
-
-The framework provides a topic-based message bus that allows you to send messages between the components of the application. It uses [AIO Pika](https://aio-pika.readthedocs.io/) as the message broker worker and publisher.
-
-```py
-    @IncomingHandler("task")
-    async def process_task(self, message: Message[Identifiable[TaskSchema]]) -> None:
-        name = generate_random_name()
-        now = asyncio.get_event_loop().time()
-        print("Processing task: ", name)
-
-        task = message.payload()
-
-        print("Received task: ", task)
-        await asyncio.sleep(random.randint(1, 5))
-
-        await use_publisher().publish(task, topic="task")
-
-        then = asyncio.get_event_loop().time()
-        print("Task Finished: ", name, " Time: ", then - now)
-```
-
-### Distributed Websocket
-
-You can setup a room-based websocket server that allows you to send messages to a specific room or broadcast messages to all connected clients. All backend instances communicates with each other using a pub/sub mechanism (such as Redis).
-
-```py
-    @WebSocketEndpoint("/ws")
-    async def ws_endpoint(self, websocket: WebSocket) -> None:
-        await websocket.accept()
-        counter.increment()
-        await use_ws_manager().add_websocket(websocket)
-        await use_ws_manager().join(["tasks"], websocket)
-        await use_ws_manager().broadcast(
-            ("New Connection (%d) from %s" % (counter.count, self.hostname)).encode()
-        )
-
-        print("New Connection (%d)" % counter.count)
-
-        while True:
-            try:
-                await websocket.receive_text()
-            except WebSocketDisconnect:
-                counter.decrement()
-                await use_ws_manager().remove_websocket(websocket)
-
-                await use_ws_manager().broadcast(
-                    (
-                        "Connection Closed (%d) from %s"
-                        % (counter.count, self.hostname)
-                    ).encode()
-                )
-                print("Connection Closed (%d)" % counter.count)
-                break
-```
-
-### Scheduled Routine
-
-You can setup a scheduled routine that runs a specific task at a specific time or interval.
-
-```py
-...
-    @ScheduledAction("* * * * * */3", allow_overlap=False)
-    async def scheduled_task(self) -> None:
-        print("Scheduled Task at ", asyncio.get_event_loop().time())
-
-        print("sleeping")
-        await asyncio.sleep(5)
-
-        await use_publisher().publish(
-            message=Identifiable(
-                id=uuid4(),
-                data=TaskSchema(name=generate_random_name()),
-            ),
-            topic="task",
-        )
-```
-
-### Observability
-
-You can setup Observability Interceptors for logs, traces and metric collection with [OpenTelemetry](https://opentelemetry.io/docs)-based Protocols
-
-```python
-class HelloService:
-    def __init__(
-        self,
-        hello_rpc: Annotated[HelloRPC, Token(HelloRPC, "HELLO_RPC")],
-    ):
-        self.hello_rpc = hello_rpc
-
-    @TracedFunc("ping") # Decorator for tracing
-    async def ping(self) -> HelloResponse:
-        return await self.hello_rpc.ping()
-
-    @TracedFunc("hello-service")
-    async def hello(
-        self,
-        gather: bool,
-    ) -> HelloResponse:
-        now = asyncio.get_event_loop().time()
-        if gather:
-            await asyncio.gather(*[self.random_await(a) for a in range(10)])
-        else:
-            for a in range(10):
-                await self.random_await(a)
-        return HelloResponse(
-            message="Elapsed time: {}".format(asyncio.get_event_loop().time() - now)
-        )
-
-    @TracedFunc("random-await")
-    async def random_await(self, index: int) -> None:
-        logger.info("Random await %s", index, extra={"index": index})
-        await asyncio.sleep(random.randint(1, 3))
-        logger.info("Random await %s done", index, extra={"index": index})
-```
-
-## Installation
-
-```bash
-pip install jararaca
-```
-
-## Usage
-
-### Create a Microservice
-
-```python
-# app.py
-
-from jararaca import Microservice, create_http_server, create_messagebus_worker
-from jararaca.presentation.http_microservice import HttpMicroservice
-
-app = Microservice(
-    providers=[
-        ProviderSpec(
-            provide=Token[AppConfig],
-            use_factory=AppConfig.provider,
-        )
-    ],
-    controllers=[TasksController],
-    interceptors=[
-        AIOSqlAlchemySessionInterceptor(
-            AIOSQAConfig(
-                connection_name="default",
-                url="sqlite+aiosqlite:///db.sqlite3",
-            )
-        ),
-    ],
-)
-
-
-# App for specific Http Configuration Context
-http_app = HttpMicroservice(app)
-
-web_app = create_http_server(app)
-
-```
-
-### Run as a Web Server
-
-```bash
-uvicorn app:web_app --reload
-# or
-jararaca server app:app
-# or
-jararaca server app:http_app
-
-```
-
-### Run as a Message Bus Worker
-
-```bash
-jararaca worker app:app
-```
-
-### Run as a scheduled routine
-
-```bash
-jararaca scheduler app:app
-```
-
-### Generate Typescript intefaces from microservice app controllers
-
-```bash
-jararaca gen-tsi app.main:app app.ts
-```
-
-### Documentation
-
-Documentation is under construction [here](https://luscasleo.github.io/jararaca/).