jararaca 0.3.0__tar.gz → 0.3.2__tar.gz

{jararaca-0.3.0 → jararaca-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jararaca
-Version: 0.3.0
+Version: 0.3.2
 Summary: A simple and fast API framework for Python
 Author: Lucas S
 Author-email: me@luscasleo.dev

{jararaca-0.3.0 → jararaca-0.3.2}/docs/scheduler.md

@@ -21,7 +21,7 @@ graph TD
     A[Microservice] --> B[Scheduler System]
     B --> C[Basic Scheduler]
     B --> D[Enhanced Scheduler V2]
-    
+
     C --> E[Local Task Execution]
     D --> F[Message Broker]
     F --> G[Workers]
@@ -39,12 +39,13 @@ You can define scheduled tasks using the `@ScheduledAction` decorator:
 ```python
 from jararaca import ScheduledAction
 
+
 class TasksController:
     @ScheduledAction("*/5 * * * *")  # Run every 5 minutes
     async def scheduled_task(self):
         # Your task implementation
         print("This runs every 5 minutes")
-        
+
     @ScheduledAction("0 */2 * * *", allow_overlap=False, timeout=60)
     async def heavy_task(self):
         # A heavier task that shouldn't overlap
@@ -85,6 +86,7 @@ app = Microservice(
 
 # Run the scheduler
 from jararaca.scheduler.scheduler import Scheduler
+
 scheduler = Scheduler(app, interval=1)
 scheduler.run()
 ```
@@ -128,7 +130,7 @@ sequenceDiagram
     participant B as Message Broker
     participant R as Redis Backend
     participant W as Worker
-    
+
     S->>R: Check last execution time
     R-->>S: Return last execution time
     S->>S: Determine if task should run
@@ -148,19 +150,20 @@ The V2 scheduler also supports delayed messages:
 from jararaca import use_publisher
 from jararaca.scheduler.types import DelayedMessageData
 
+
 # Schedule a message to be published at a future time
 async def schedule_reminder():
     message = ReminderMessage(
         user_id="123",
         message="Don't forget your appointment!"
     )
-    
+
     # Current time + 1 hour in seconds
     dispatch_time = int(time.time()) + 3600
-    
+
     # Get publisher
     publisher = use_publisher()
-    
+
     # Schedule delayed message
     await publisher.publish_delayed(
         message,
@@ -213,4 +216,4 @@ jararaca scheduler_v2 APP_PATH [OPTIONS]
 
 ## Conclusion
 
-The Jararaca scheduler system provides a powerful, flexible way to implement periodic tasks in your applications. With two implementations to choose from, you can select the one that best fits your application's requirements, from simple local scheduling to complex distributed task execution.
+The Jararaca scheduler system provides a powerful, flexible way to implement periodic tasks in your applications. With two implementations to choose from, you can select the one that best fits your application's requirements, from simple local scheduling to complex distributed task execution.

{jararaca-0.3.0 → jararaca-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jararaca"
-version = "0.3.0"
+version = "0.3.2"
 description = "A simple and fast API framework for Python"
 authors = ["Lucas S <me@luscasleo.dev>"]
 readme = "README.md"

{jararaca-0.3.0 → jararaca-0.3.2}/src/jararaca/cli.py

@@ -1,9 +1,11 @@
 import importlib
 import importlib.resources
+import multiprocessing
 import os
 import sys
 import time
 from codecs import StreamWriter
+from pathlib import Path
 from typing import Any
 from urllib.parse import urlparse, urlunsplit
 
@@ -265,6 +267,30 @@ def scheduler_v2(
     scheduler.run()
 
 
+def generate_interfaces(app_path: str, file_path: str) -> None:
+    try:
+        app = find_microservice_by_module_path(app_path)
+        content = write_microservice_to_typescript_interface(app)
+
+        with open(file_path, "w", encoding="utf-8") as file:
+            # Save current position
+            file.tell()
+
+            # Reset file to beginning
+            file.seek(0)
+            file.truncate()
+
+            # Write new content
+            file.write(content)
+            file.flush()
+
+        print(
+            f"Generated TypeScript interfaces at {time.strftime('%H:%M:%S')} at {str(Path(file_path).absolute())}"
+        )
+    except Exception as e:
+        print(f"Error generating TypeScript interfaces: {e}", file=sys.stderr)
+
+
 @cli.command()
 @click.argument(
     "app_path",
@@ -272,7 +298,7 @@ def scheduler_v2(
 )
 @click.argument(
     "file_path",
-    type=click.File("w"),
+    type=click.Path(file_okay=True, dir_okay=False),
 )
 @click.option(
     "--watch",
@@ -283,32 +309,11 @@ def scheduler_v2(
     type=click.Path(exists=True, file_okay=False, dir_okay=True),
     default="src",
 )
-def gen_tsi(app_path: str, file_path: StreamWriter, watch: bool, src_dir: str) -> None:
+def gen_tsi(app_path: str, file_path: str, 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()
-
-            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)
-
     # Initial generation
-    generate_interfaces()
+    generate_interfaces(app_path, file_path)
 
     # If watch mode is not enabled, exit
     if not watch:
@@ -334,7 +339,33 @@ def gen_tsi(app_path: str, file_path: StreamWriter, watch: bool, src_dir: str) -
             )
             if not event.is_directory and src_path.endswith(".py"):
                 print(f"File changed: {src_path}")
-                generate_interfaces()
+                # Create a completely detached process to ensure classes are reloaded
+                process = multiprocessing.get_context("spawn").Process(
+                    target=generate_interfaces,
+                    args=(app_path, file_path),
+                    daemon=False,  # Non-daemon to ensure it completes
+                )
+                process.start()
+                # Don't join to keep it detached from main process
+
+        def _run_generator_in_separate_process(
+            self, app_path: str, file_path: str
+        ) -> None:
+            # Using Python executable to start a completely new process
+            # This ensures all modules are freshly imported
+            generate_interfaces(app_path, file_path)
+            # cmd = [
+            #     sys.executable,
+            #     "-c",
+            #     (
+            #         f"import sys; sys.path.extend({sys.path}); "
+            #         f"from jararaca.cli import generate_interfaces; "
+            #         f"generate_interfaces('{app_path}', '{file_path}')"
+            #     ),
+            # ]
+            # import subprocess
+
+            # subprocess.run(cmd, check=False)
 
     # Set up observer
     observer = Observer()

{jararaca-0.3.0 → jararaca-0.3.2}/src/jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py

@@ -1,3 +1,4 @@
+import logging
 from contextlib import asynccontextmanager
 from datetime import datetime, timedelta
 from datetime import tzinfo as _TzInfo
@@ -29,10 +30,10 @@ class AIOPikaMessagePublisher(MessagePublisher):
         self.message_broker_backend = message_broker_backend
 
     async def publish(self, message: IMessage, topic: str) -> None:
-        exchange = await self.channel.declare_exchange(
-            self.exchange_name,
-            type=aio_pika.ExchangeType.TOPIC,
-        )
+        exchange = await self.channel.get_exchange(self.exchange_name, ensure=False)
+        if not exchange:
+            logging.warning(f"Exchange {self.exchange_name} not found")
+            return
         routing_key = f"{topic}."
         await exchange.publish(
             aio_pika.Message(body=message.model_dump_json().encode()),

{jararaca-0.3.0 → jararaca-0.3.2}/src/jararaca/tools/typescript/interface_parser.py

@@ -193,10 +193,11 @@ def parse_type_to_typescript_interface(
     mapped_types.update(inherited_classes)
 
     if Enum in inherited_classes:
+        enum_values = sorted([(x._name_, x.value) for x in basemodel_type])
         return (
             set(),
             f"export enum {basemodel_type.__name__} {{\n"
-            + "\n ".join([f'\t{x._name_} = "{x.value}",' for x in basemodel_type])
+            + "\n ".join([f'\t{name} = "{value}",' for name, value in enum_values])
             + "\n}\n",
         )
 
@@ -222,31 +223,39 @@ def parse_type_to_typescript_interface(
     extends_expression = (
         " extends %s"
         % ", ".join(
-            [
-                (
-                    "%s" % get_field_type_for_ts(inherited_class)
-                    if not inherited_classes_consts_conflict[inherited_class]
-                    else "Omit<%s, %s>"
-                    % (
-                        get_field_type_for_ts(inherited_class),
-                        " | ".join(
-                            '"%s"' % field_name
-                            for field_name in inherited_classes_consts_conflict[
-                                inherited_class
-                            ]
-                        ),
+            sorted(
+                [
+                    (
+                        "%s" % get_field_type_for_ts(inherited_class)
+                        if not inherited_classes_consts_conflict[inherited_class]
+                        else "Omit<%s, %s>"
+                        % (
+                            get_field_type_for_ts(inherited_class),
+                            " | ".join(
+                                sorted(
+                                    [
+                                        '"%s"' % field_name
+                                        for field_name in inherited_classes_consts_conflict[
+                                            inherited_class
+                                        ]
+                                    ]
+                                )
+                            ),
+                        )
                     )
-                )
-                for inherited_class in valid_inherited_classes
-            ]
+                    for inherited_class in valid_inherited_classes
+                ],
+                key=lambda x: str(x),
+            )
         )
         if len(valid_inherited_classes) > 0
         else ""
     )
 
     if is_generic_type(basemodel_type):
+        generic_args = get_generic_args(basemodel_type)
         string_builder.write(
-            f"export interface {basemodel_type.__name__}<{', '.join([arg.__name__ for arg in get_generic_args(basemodel_type)])}>{extends_expression} {{\n"
+            f"export interface {basemodel_type.__name__}<{', '.join(sorted([arg.__name__ for arg in generic_args]))}>{extends_expression} {{\n"
         )
     else:
         string_builder.write(
@@ -254,12 +263,12 @@ def parse_type_to_typescript_interface(
         )
 
     if hasattr(basemodel_type, "__annotations__"):
-        # for field_name in (f for f in dir(basemodel_type) if is_constant(f)):
-        #     field = getattr(basemodel_type, field_name)
-        #     if field is None:
-        #         continue
-        #     string_builder.write(f"  {field_name}: {parse_literal_value(field)};\n")
-        for field_name, field in basemodel_type.__annotations__.items():
+        # Sort fields for consistent output
+        annotation_items = sorted(
+            basemodel_type.__annotations__.items(), key=lambda x: x[0]
+        )
+
+        for field_name, field in annotation_items:
             if field_name in cls_consts:
                 continue
 
@@ -277,8 +286,11 @@ def parse_type_to_typescript_interface(
             mapped_types.update(extract_all_envolved_types(field))
             mapped_types.add(field)
 
-    ## Loop over computed fields
-    members = inspect.getmembers(basemodel_type, lambda a: isinstance(a, property))
+    ## Loop over computed fields - sort them for consistent output
+    members = sorted(
+        inspect.getmembers(basemodel_type, lambda a: isinstance(a, property)),
+        key=lambda x: x[0],
+    )
     for field_name, field in members:
         if hasattr(field, "fget"):
             module_func_name = field.fget.__module__ + "." + field.fget.__qualname__
@@ -359,11 +371,13 @@ export type WebSocketMessageMap = {
 }
 """
         % "\n".join(
-            [
-                f'\t"{message.MESSAGE_ID}": {message.__name__};'
-                for registers in websocket_registries
-                for message in registers.message_types
-            ]
+            sorted(
+                [
+                    f'\t"{message.MESSAGE_ID}": {message.__name__};'
+                    for registers in websocket_registries
+                    for message in registers.message_types
+                ]
+            )
         )
     )
 
@@ -477,7 +491,12 @@ def write_rest_controller_to_typescript_interface(
 
     mapped_types: set[Any] = set()
 
-    for name, member in inspect.getmembers(controller, predicate=inspect.isfunction):
+    # Sort members for consistent output
+    member_items = sorted(
+        inspect.getmembers(controller, predicate=inspect.isfunction), key=lambda x: x[0]
+    )
+
+    for name, member in member_items:
         if (mapping := HttpMapping.get_http_mapping(member)) is not None:
             return_type = member.__annotations__.get("return")
 
@@ -514,17 +533,24 @@ def write_rest_controller_to_typescript_interface(
             )
             class_buffer.write(f"\t\t\tpath: `/{final_path}`,\n")
 
+            # Sort headers
+            header_params = sorted(
+                [param for param in arg_params_spec if param.type_ == "header"],
+                key=lambda x: x.name,
+            )
             class_buffer.write("\t\t\theaders: {\n")
-            for param in arg_params_spec:
-                if param.type_ == "header":
-                    class_buffer.write(f'\t\t\t\t"{param.name}": {param.name},\n')
-
+            for param in header_params:
+                class_buffer.write(f'\t\t\t\t"{param.name}": {param.name},\n')
             class_buffer.write("\t\t\t},\n")
-            class_buffer.write("\t\t\tquery: {\n")
 
-            for param in arg_params_spec:
-                if param.type_ == "query":
-                    class_buffer.write(f'\t\t\t\t"{param.name}": {param.name},\n')
+            # Sort query params
+            query_params = sorted(
+                [param for param in arg_params_spec if param.type_ == "query"],
+                key=lambda x: x.name,
+            )
+            class_buffer.write("\t\t\tquery: {\n")
+            for param in query_params:
+                class_buffer.write(f'\t\t\t\t"{param.name}": {param.name},\n')
             class_buffer.write("\t\t\t},\n")
 
             if (