robyn 0.73.0__cp311-cp311-macosx_10_12_x86_64.whl

robyn/reloader.py

@@ -0,0 +1,164 @@
+import glob
+import os
+import signal
+import subprocess
+import sys
+import time
+from typing import List, Union
+
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+from robyn.logger import Colors, logger
+
+
+def compile_rust_files(directory_path: str) -> List[str]:
+    rust_files = glob.glob(os.path.join(directory_path, "**/*.rs"), recursive=True)
+    rust_binaries: list[str] = []
+
+    for rust_file in rust_files:
+        print(f"Compiling rust file: {rust_file}")
+
+        result = subprocess.run(
+            [sys.executable, "-m", "rustimport", "build", rust_file],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            start_new_session=False,
+        )
+        if result.returncode != 0:
+            print(f"Error compiling rust file: {rust_file} \n {result.stderr.decode('utf-8')} \n {result.stdout.decode('utf-8')}")
+        else:
+            print(f"Compiled rust file: {rust_file}")
+            rust_file_base = rust_file.removesuffix(".rs")
+
+            # Define the search pattern for the binary file
+            if sys.platform == "win32":
+                binary_extension = ".dll"
+            elif sys.platform == "darwin":
+                binary_extension = ".so"
+            elif sys.platform == "linux":
+                binary_extension = ".so"
+            else:
+                raise ValueError(f"Unsupported platform: {sys.platform}")
+
+            search_pattern = f"{rust_file_base}.*{binary_extension}"
+            # Use glob to find matching binary files
+            matching_binaries = glob.glob(search_pattern)
+            rust_binaries.extend(matching_binaries)
+
+    return rust_binaries
+
+
+def create_rust_file(file_name: str) -> None:
+    if file_name.endswith(".rs"):
+        file_name = file_name.removesuffix(".rs")
+
+    rust_file = f"{file_name}.rs"
+
+    result = subprocess.run(
+        [sys.executable, "-m", "rustimport", "new", rust_file],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        start_new_session=False,
+    )
+
+    if result.returncode != 0:
+        print(
+            "Error creating rust file : %s %s",
+            result.stderr.decode("utf-8"),
+            result.stdout.decode("utf-8"),
+        )
+    else:
+        print("Created rust file : %s", rust_file)
+
+
+def clean_rust_binaries(rust_binaries: List[str]) -> None:
+    for file in rust_binaries:
+        print("Cleaning rust file : %s", file)
+        os.remove(file)
+
+
+def setup_reloader(directory_path: str, file_path: str) -> None:
+    event_handler = EventHandler(file_path, directory_path)
+
+    # sets the IS_RELOADER_RUNNING environment variable to True
+    event_handler.reload()
+
+    logger.info(
+        "Dev server initialized with the directory_path : %s",
+        directory_path,
+        color=Colors.BLUE,
+    )
+
+    def terminating_signal_handler(_sig, _frame):
+        event_handler.stop_server()
+        logger.info("Terminating reloader", bold=True)
+        observer.stop()
+        observer.join()
+
+    signal.signal(signal.SIGINT, terminating_signal_handler)
+    signal.signal(signal.SIGTERM, terminating_signal_handler)
+
+    observer = Observer()
+    observer.schedule(event_handler, path=directory_path, recursive=True)
+    observer.start()
+
+    try:
+        while observer.is_alive():
+            observer.join(1)
+    finally:
+        observer.stop()
+        observer.join()
+        event_handler.process.wait()
+
+
+class EventHandler(FileSystemEventHandler):
+    def __init__(self, file_path: str, directory_path: str) -> None:
+        self.file_path = file_path
+        self.directory_path = directory_path
+        self.process: Union[subprocess.Popen[bytes], None] = None  # Keep track of the subprocess
+        self.built_rust_binaries: List = []  # Keep track of the built rust binaries
+
+        self.last_reload = time.time()  # Keep track of the last reload. EventHandler is initialized with the process.
+
+    def stop_server(self) -> None:
+        if self.process:
+            os.kill(self.process.pid, signal.SIGTERM)  # Stop the subprocess using os.kill()
+
+    def reload(self) -> None:
+        self.stop_server()
+        print("Reloading the server")
+
+        new_env = os.environ.copy()
+        new_env["IS_RELOADER_RUNNING"] = "True"  # This is used to check if a reloader is already running
+        # IS_RELOADER_RUNNING is specifically used for IPC between the reloader and the server
+
+        arguments = [arg for arg in sys.argv[1:] if not arg.startswith("--dev")]
+
+        clean_rust_binaries(self.built_rust_binaries)
+        self.built_rust_binaries = compile_rust_files(self.directory_path)
+
+        prev_process = self.process
+        if prev_process:
+            prev_process.kill()
+
+        self.process = subprocess.Popen(
+            [sys.executable, *arguments],
+            env=new_env,
+        )
+
+        self.last_reload = time.time()
+
+    def on_modified(self, event) -> None:
+        """
+        This function is a callback that will start a new server on every even change
+
+        :param event FSEvent: a data structure with info about the events
+        """
+
+        # Avoid reloading multiple times when watchdog detects multiple events
+        if time.time() - self.last_reload < 0.5:
+            return
+
+        time.sleep(0.2)  # Wait for the file to be fully written
+        self.reload()

robyn/responses.py

@@ -0,0 +1,208 @@
+import asyncio
+import mimetypes
+import os
+from typing import AsyncGenerator, Generator, Optional, Union
+
+from robyn.robyn import Headers, Response
+
+
+class FileResponse:
+    def __init__(
+        self,
+        file_path: str,
+        status_code: Optional[int] = None,
+        headers: Optional[Headers] = None,
+    ):
+        self.file_path = file_path
+        self.description = ""
+        self.status_code = status_code or 200
+        self.headers = headers or Headers({"Content-Disposition": "attachment"})
+
+
+def html(html: str) -> Response:
+    """
+    This function will help in serving a simple html string
+
+    :param html str: html to serve as a response
+    """
+    return Response(
+        description=html,
+        status_code=200,
+        headers=Headers({"Content-Type": "text/html"}),
+    )
+
+
+def serve_html(file_path: str) -> FileResponse:
+    """
+    This function will help in serving a single html file
+
+    :param file_path str: file path to serve as a response
+    """
+
+    return FileResponse(file_path, headers=Headers({"Content-Type": "text/html"}))
+
+
+def serve_file(file_path: str, file_name: Optional[str] = None) -> FileResponse:
+    """
+    This function will help in serving a file
+
+    :param file_path str: file path to serve as a response
+    :param file_name [str | None]: file name to serve as a response, defaults to None
+    """
+    file_name = file_name or os.path.basename(file_path)
+
+    mime_type = mimetypes.guess_type(file_name)[0]
+
+    headers = Headers({"Content-Type": mime_type})
+    headers.append("Content-Disposition", f"attachment; filename={file_name}")
+
+    return FileResponse(
+        file_path,
+        headers=headers,
+    )
+
+
+class AsyncGeneratorWrapper:
+    """Optimized true-streaming wrapper for async generators"""
+
+    def __init__(self, async_gen: AsyncGenerator[str, None]):
+        self.async_gen = async_gen
+        self._loop = None
+        self._iterator = None
+        self._exhausted = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._exhausted:
+            raise StopIteration
+
+        # Initialize the loop and iterator only once
+        if self._iterator is None:
+            self._init_async_iterator()
+
+        try:
+            # Get the next value from the async generator
+            # This is the key optimization - we don't buffer, we get one value at a time
+            return self._get_next_value()
+        except StopIteration:
+            self._exhausted = True
+            raise
+
+    def _init_async_iterator(self):
+        """Initialize the async iterator with proper loop handling"""
+        try:
+            # Try to get the running event loop
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No running loop, create a new one
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+
+        # Create the async iterator
+        self._iterator = self.async_gen.__aiter__()
+
+    def _get_next_value(self):
+        """Get the next value from async generator without buffering"""
+        try:
+            # Create a coroutine to get the next value
+            async def get_next():
+                return await self._iterator.__anext__()
+
+            # Run the coroutine to get the next value
+            return self._loop.run_until_complete(get_next())
+        except StopAsyncIteration:
+            # Convert StopAsyncIteration to StopIteration for sync generator protocol
+            raise StopIteration
+        except Exception as e:
+            # Log error and stop iteration
+            print(f"Error in async generator: {e}")
+            raise StopIteration
+
+
+class StreamingResponse:
+    def __init__(
+        self,
+        content: Union[Generator[str, None, None], AsyncGenerator[str, None]],
+        status_code: Optional[int] = None,
+        headers: Optional[Headers] = None,
+        media_type: str = "text/event-stream",
+    ):
+        # Convert async generator to sync generator if needed
+        # The Rust implementation detects async generators but falls back to Python wrapper
+        if hasattr(content, "__anext__"):
+            # This is an async generator - wrap it with optimized wrapper
+            self.content = AsyncGeneratorWrapper(content)
+        else:
+            # This is a sync generator - use as is
+            self.content = content
+
+        self.status_code = status_code or 200
+        self.headers = headers or Headers({})
+        self.media_type = media_type
+
+        # Set default SSE headers
+        if media_type == "text/event-stream":
+            self.headers.set("Content-Type", "text/event-stream")
+            # Cache-Control and Connection headers are set by Rust layer with optimized headers
+            self.headers.set("Access-Control-Allow-Origin", "*")
+            self.headers.set("Access-Control-Allow-Headers", "Cache-Control")
+
+
+def SSEResponse(
+    content: Union[Generator[str, None, None], AsyncGenerator[str, None]],
+    status_code: Optional[int] = None,
+    headers: Optional[Headers] = None,
+) -> StreamingResponse:
+    """
+    Create a Server-Sent Events (SSE) streaming response.
+
+    :param content: Generator or AsyncGenerator yielding SSE-formatted strings
+    :param status_code: HTTP status code (default: 200)
+    :param headers: Additional headers
+    :return: StreamingResponse configured for SSE
+    """
+    return StreamingResponse(content=content, status_code=status_code, headers=headers, media_type="text/event-stream")
+
+
+def SSEMessage(data: str, event: Optional[str] = None, id: Optional[str] = None, retry: Optional[int] = None) -> str:
+    """
+    Optimized SSE message formatting with minimal allocations.
+
+    :param data: The message data
+    :param event: Optional event type
+    :param id: Optional event ID
+    :param retry: Optional retry time in milliseconds
+    :return: SSE-formatted string
+    """
+    # Pre-calculate size to avoid multiple string concatenations
+    parts = []
+
+    # Add optional fields first
+    if event:
+        parts.append(f"event: {event}\n")
+    if id:
+        parts.append(f"id: {id}\n")
+    if retry:
+        parts.append(f"retry: {retry}\n")
+
+    # Handle data with optimized multi-line processing
+    if data:
+        data_str = str(data)
+        # Fast path for single-line data (most common case)
+        if "\n" not in data_str and "\r" not in data_str:
+            parts.append(f"data: {data_str}\n")
+        else:
+            # Multi-line data handling
+            normalized_data = data_str.replace("\r\n", "\n").replace("\r", "\n")
+            for line in normalized_data.split("\n"):
+                parts.append(f"data: {line}\n")
+    else:
+        parts.append("data: \n")
+
+    # Add the required double newline terminator
+    parts.append("\n")
+
+    # Single join operation for optimal performance
+    return "".join(parts)