hypern 0.2.0__cp312-none-win_amd64.whl → 0.2.1__cp312-none-win_amd64.whl

hypern/application.py

@@ -2,23 +2,21 @@
 from __future__ import annotations
 
 import asyncio
-import socket
 from typing import Any, Callable, List, TypeVar
 
 import orjson
 from typing_extensions import Annotated, Doc
 
 from hypern.datastructures import Contact, HTTPMethod, Info, License
-from hypern.exceptions import InvalidPortNumber
 from hypern.hypern import FunctionInfo, Router
 from hypern.hypern import Route as InternalRoute
-from hypern.logging import logger
 from hypern.openapi import SchemaGenerator, SwaggerUI
 from hypern.processpool import run_processes
 from hypern.response import HTMLResponse, JSONResponse
 from hypern.routing import Route
 from hypern.scheduler import Scheduler
 from hypern.middleware import Middleware
+from hypern.args_parser import ArgsConfig
 
 AppType = TypeVar("AppType", bound="Hypern")
 
@@ -193,6 +191,7 @@ class Hypern:
         self.middleware_before_request = []
         self.middleware_after_request = []
         self.response_headers = {}
+        self.args = ArgsConfig()
 
         for route in routes:
             self.router.extend_route(route(app=self).routes)
@@ -340,60 +339,30 @@ class Hypern:
             self.after_request()(after_request)
         return self
 
-    def is_port_in_use(self, port: int) -> bool:
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                return s.connect_ex(("localhost", port)) == 0
-        except Exception:
-            raise InvalidPortNumber(f"Invalid port number: {port}")
-
     def start(
         self,
-        host: Annotated[str, Doc("The host to run the server on. Defaults to `127.0.0.1`")] = "127.0.0.1",
-        port: Annotated[int, Doc("The port to run the server on. Defaults to `8080`")] = 8080,
-        workers: Annotated[int, Doc("The number of workers to run. Defaults to `1`")] = 1,
-        processes: Annotated[int, Doc("The number of processes to run. Defaults to `1`")] = 1,
-        max_blocking_threads: Annotated[int, Doc("The maximum number of blocking threads. Defaults to `100`")] = 1,
-        check_port: Annotated[bool, Doc("Check if the port is already in use. Defaults to `True`")] = False,
     ):
         """
         Starts the server with the specified configuration.
-
-        Args:
-            host (str): The host to run the server on. Defaults to `127.0.0.1`.
-            port (int): The port to run the server on. Defaults to `8080`.
-            workers (int): The number of workers to run. Defaults to `1`.
-            processes (int): The number of processes to run. Defaults to `1`.
-            max_blocking_threads (int): The maximum number of blocking threads. Defaults to `100`.
-            check_port (bool): Check if the port is already in use. Defaults to `True`.
-
         Raises:
             ValueError: If an invalid port number is entered when prompted.
 
         """
-        if check_port:
-            while self.is_port_in_use(port):
-                logger.error("Port %s is already in use. Please use a different port.", port)
-                try:
-                    port = int(input("Enter a different port: "))
-                except Exception:
-                    logger.error("Invalid port number. Please enter a valid port number.")
-                    continue
-
         if self.scheduler:
             self.scheduler.start()
 
         run_processes(
-            host=host,
-            port=port,
-            workers=workers,
-            processes=processes,
-            max_blocking_threads=max_blocking_threads,
+            host=self.args.host,
+            port=self.args.port,
+            workers=self.args.workers,
+            processes=self.args.processes,
+            max_blocking_threads=self.args.max_blocking_threads,
             router=self.router,
             injectables=self.injectables,
             before_request=self.middleware_before_request,
             after_request=self.middleware_after_request,
             response_headers=self.response_headers,
+            reload=self.args.reload,
         )
 
     def add_route(self, method: HTTPMethod, endpoint: str, handler: Callable[..., Any]):

hypern/args_parser.py

@@ -0,0 +1,59 @@
+import argparse
+
+
+class ArgsConfig:
+    def __init__(self) -> None:
+        parser = argparse.ArgumentParser(description="Hypern: A Versatile Python and Rust Framework")
+        self.parser = parser
+        parser.add_argument(
+            "--host",
+            type=str,
+            default=None,
+            required=False,
+            help="Choose the host. [Defaults to `127.0.0.1`]",
+        )
+
+        parser.add_argument(
+            "--port",
+            type=int,
+            default=None,
+            required=False,
+            help="Choose the port. [Defaults to `5000`]",
+        )
+
+        parser.add_argument(
+            "--processes",
+            type=int,
+            default=None,
+            required=False,
+            help="Choose the number of processes. [Default: 1]",
+        )
+        parser.add_argument(
+            "--workers",
+            type=int,
+            default=None,
+            required=False,
+            help="Choose the number of workers. [Default: 1]",
+        )
+
+        parser.add_argument(
+            "--max-blocking-threads",
+            type=int,
+            default=None,
+            required=False,
+            help="Choose the maximum number of blocking threads. [Default: 100]",
+        )
+
+        parser.add_argument(
+            "--reload",
+            action="store_true",
+            help="It restarts the server based on file changes.",
+        )
+        args, _ = parser.parse_known_args()
+
+        self.host = args.host or "127.0.0.1"
+        self.port = args.port or 5000
+        self.max_blocking_threads = args.max_blocking_threads or 100
+        self.processes = args.processes or 1
+        self.workers = args.workers or 1
+        self.reload = args.reload or False

hypern/logging/logger.py

@@ -59,7 +59,7 @@ class ColourizedFormatter(logging.Formatter):
                 recordcopy.__dict__["message"] = recordcopy.getMessage()
         recordcopy.__dict__["levelprefix"] = levelname + separator
         recordcopy.__dict__["process"] = click.style(str(process), fg="blue")
-        recordcopy.__dict__["asctime"] = click.style(datetime.fromtimestamp(created, tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S.%fZ"), fg=(101, 111, 104))
+        recordcopy.__dict__["asctime"] = click.style(datetime.fromtimestamp(created, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), fg=(101, 111, 104))
         recordcopy.__dict__["filename"] = click.style(f"{module}/{filename}:{lineno}:", fg=(101, 111, 104))
         return super().formatMessage(recordcopy)
 

hypern/processpool.py

@@ -1,12 +1,15 @@
 import asyncio
+import os
 import signal
 import sys
 from typing import Any, Dict, List
 
 from multiprocess import Process
+from watchdog.observers import Observer
 
 from .hypern import FunctionInfo, Router, Server, SocketHeld
 from .logging import logger
+from .reload import EventHandler
 
 
 def run_processes(
@@ -20,6 +23,7 @@ def run_processes(
     before_request: List[FunctionInfo],
     after_request: List[FunctionInfo],
     response_headers: Dict[str, str],
+    reload: bool = True,
 ) -> List[Process]:
     socket = SocketHeld(host, port)
 
@@ -33,9 +37,30 @@ def run_processes(
     signal.signal(signal.SIGINT, terminating_signal_handler)
     signal.signal(signal.SIGTERM, terminating_signal_handler)
 
-    logger.info("Press Ctrl + C to stop \n")
-    for process in process_pool:
-        process.join()
+    if reload:
+        # Set up file system watcher for auto-reload
+        watch_dirs = [os.getcwd()]
+        observer = Observer()
+        reload_handler = EventHandler(file_path=sys.argv[0], directory_path=os.getcwd())
+
+        for directory in watch_dirs:
+            observer.schedule(reload_handler, directory, recursive=True)
+
+        observer.start()
+
+    logger.info(f"Server started at http://{host}:{port}")
+    logger.info("Press Ctrl + C to stop")
+
+    try:
+        for process in process_pool:
+            logger.debug(f"Process {process.pid} started")
+            process.join()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        if reload:
+            observer.stop()
+            observer.join()
 
     return process_pool
 

hypern/reload.py

@@ -0,0 +1,60 @@
+import sys
+import time
+import subprocess
+from watchdog.events import FileSystemEventHandler
+
+from .logging import logger
+
+
+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 = None  # Keep track of the subprocess
+        self.last_reload = time.time()  # Keep track of the last reload. EventHandler is initialized with the process.
+
+    def stop_server(self):
+        if self.process:
+            try:
+                # Check if the process is still alive
+                if self.process.poll() is None:  # None means the process is still running
+                    self.process.terminate()  # Gracefully terminate the process
+                    self.process.wait(timeout=5)  # Wait for the process to exit
+                else:
+                    logger.error("Process is not running.")
+            except subprocess.TimeoutExpired:
+                logger.error("Process did not terminate in time. Forcing termination.")
+                self.process.kill()  # Forcefully kill the process if it doesn't stop
+            except ProcessLookupError:
+                logger.error("Process does not exist.")
+            except Exception as e:
+                logger.error(f"An error occurred while stopping the server: {e}")
+        else:
+            logger.debug("No process to stop.")
+
+    def reload(self):
+        self.stop_server()
+        logger.debug("Reloading the server")
+        prev_process = self.process
+        if prev_process:
+            prev_process.kill()
+
+        self.process = subprocess.Popen(
+            [sys.executable, *sys.argv],
+        )
+
+        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()

{hypern-0.2.0.dist-info → hypern-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hypern
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -22,6 +22,7 @@ Requires-Dist: orjson ==3.10.11
 Requires-Dist: multiprocess ==0.70.17
 Requires-Dist: uvloop ==0.21.0 ; sys_platform != 'win32' and platform_python_implementation == 'CPython' and platform_machine != 'armv7l'
 Requires-Dist: cryptography ==43.0.3
+Requires-Dist: watchdog ==6.0.0
 License-File: LICENSE
 Summary: A Fast Async Python backend with a Rust runtime.
 Author-email: Martin Dang <vannghiem848@gmail.com>

{hypern-0.2.0.dist-info → hypern-0.2.1.dist-info}/RECORD

@@ -1,7 +1,8 @@
-hypern-0.2.0.dist-info/METADATA,sha256=0dwMDftVhFSbT6b6f41rTkO-2VTmxvLyUNBgblWBXc0,3722
-hypern-0.2.0.dist-info/WHEEL,sha256=VGMDu5jnp_XpyXOq-L1-cbr3x9_PzCpsKi1udyLAeSI,95
-hypern-0.2.0.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
-hypern/application.py,sha256=W_eltIwV2WcTaAQonxstMebGGgvMkIujowNvLYTX0nc,15183
+hypern-0.2.1.dist-info/METADATA,sha256=PczP9NPw85PZdaLvHplRZCSGQ5bs0FRQlaWXUp9bfYU,3754
+hypern-0.2.1.dist-info/WHEEL,sha256=VGMDu5jnp_XpyXOq-L1-cbr3x9_PzCpsKi1udyLAeSI,95
+hypern-0.2.1.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=IUa1O9L3bU3VwEo6nbrKGHqy5Wx1-x1n1sSayt9P6Mg,13399
+hypern/args_parser.py,sha256=Crxzr8_uhiIk_AWJvuwJTEfRqEBqU_GfTbg6chg_YiY,1790
 hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
 hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/background.py,sha256=xy38nQZSJsYFRXr3-uFJeNW9E1GiXXOC7lSe5pC0eyE,124
@@ -39,7 +40,7 @@ hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
 hypern/exceptions.py,sha256=nHTkF0YdNBMKfSiNtjRMHMNKoY3RMUm68YYluuW15us,2428
 hypern/hypern.pyi,sha256=PsoQ-UV3q_xJs0BsW3In8gVWJjmqrffCY4xTC0hSDfk,6915
 hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hypern/logging/logger.py,sha256=ebLT-DX5OOt1UqP2OajFTm4I9tL6RSBN_GbJEKe4UI4,3256
+hypern/logging/logger.py,sha256=WACam_IJiCMXX0hGVKMGSxUQpY4DgAXy7M1dD3q-Z9s,3256
 hypern/logging/__init__.py,sha256=6eVriyncsJ4J73fGYhoejv9MX7aGTkRezTpPxO4DX1I,52
 hypern/middleware/base.py,sha256=mJoz-i-7lqw1eDxZ8Bb0t8sz60lx5TE-OjZT4UR75e4,541
 hypern/middleware/cors.py,sha256=x90DnCOJSfp4ojm1krttn_EdtlqeDazyUzVg66NES4A,1681
@@ -49,8 +50,9 @@ hypern/middleware/__init__.py,sha256=lXwR3fdmpVK4Z7QWaLsgf3Sazy5NPPFXIOxIEv1xDC8
 hypern/openapi/schemas.py,sha256=YHfMlPUeP5DzDX5ao3YH8p_25Vvyaf616dh6XDCUZRc,1677
 hypern/openapi/swagger.py,sha256=naqUY3rFAEYA1ZLIlmDsMYaol0yIm6TVebdkFa5cMTc,64
 hypern/openapi/__init__.py,sha256=4rEVD8pa0kdSpsy7ZkJ5JY0Z2XF0NGSKDMwYAd7YZpE,141
-hypern/processpool.py,sha256=_vtC9mmEisfDWuSH9prvgaipbHdP5tszPWEwqsxQGo4,3031
+hypern/processpool.py,sha256=1oLytripLMFu3RxCdvLx5G2NU_vaxEJmZyfq5FjfRtA,3788
 hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/reload.py,sha256=d28xP7MWiO2vL6RAAlIqSh8q7_ugsRBN66Mlbz3UWEI,2293
 hypern/response/response.py,sha256=-dnboAraPic8asf503PxwmDuxhNllUO5h97_DGmbER4,4582
 hypern/response/__init__.py,sha256=_w3u3TDNuYx5ejnnN1unqnTY8NlBgUATQi6wepEB_FQ,226
 hypern/routing/dispatcher.py,sha256=i2wLAAW1ZXgpi5K2heGXhTODnP1WdQzaR5WlUjs1o9c,2368
@@ -62,5 +64,5 @@ hypern/scheduler.py,sha256=-k3tW2AGCnHYSthKXk-FOs_SCtWp3yIxQzwzUJMJsbo,67
 hypern/security.py,sha256=3E86Yp_eOSVa1emUvBrDgoF0Sn6eNX0CfLnt87w5CPI,1773
 hypern/worker.py,sha256=WQrhY_awR6zjMwY4Q7izXi4E4fFrDqt7jIblUW8Bzcg,924
 hypern/__init__.py,sha256=9Ww_aUQ0vJls0tOq7Yw1_TVOCRsa5bHJ-RtnSeComwk,119
-hypern/hypern.cp312-win_amd64.pyd,sha256=tW0O9hPiYkkNB-ev14wiefs0CIvcZHVnmUbkOEUywYo,6056960
-hypern-0.2.0.dist-info/RECORD,,
+hypern/hypern.cp312-win_amd64.pyd,sha256=kF5uvmgCkYzxEPDH6w8UU53SMlOU6TeQbZIashEysK4,6056960
+hypern-0.2.1.dist-info/RECORD,,