hypern 0.2.0__cp312-cp312-macosx_10_12_x86_64.whl → 0.2.1__cp312-cp312-macosx_10_12_x86_64.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,6 +1,6 @@
-hypern-0.2.0.dist-info/METADATA,sha256=vr_oCiPq5bDdIyTt0w6S_phtY8IvEX-oRW407K-Wd-o,3626
-hypern-0.2.0.dist-info/WHEEL,sha256=i-50AaV3q8zthgSaPZNLbaFczY3NRyGbQDASQt3eucc,106
-hypern-0.2.0.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
+hypern-0.2.1.dist-info/METADATA,sha256=XnBEky_cZRe5MMTijuguzD2xMsbXI8Jc0mLvXmlO1Zo,3658
+hypern-0.2.1.dist-info/WHEEL,sha256=i-50AaV3q8zthgSaPZNLbaFczY3NRyGbQDASQt3eucc,106
+hypern-0.2.1.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
 hypern/worker.py,sha256=kN93QGx4bst0inHRO_fsTzMmhDA0N3pdzaqNXwyu3N0,894
 hypern/middleware/cors.py,sha256=SfG-3vAS-4MPXqsIsegNwDx9mqC9lvgUc3RuYzN6HNg,1643
 hypern/middleware/__init__.py,sha256=YpgxL7GQkzZM91VCNxHT2xmTa1R1b_BUS8n3tZ2b1Ys,268
@@ -10,6 +10,7 @@ hypern/middleware/base.py,sha256=Llcg9wglcumvY4BqaTfrX1OOZDqns4wb34wGF55EXcI,523
 hypern/config.py,sha256=v9KLL6snReAETKiVb8x3KOFrXpYd8-Io5tM7eruR85U,4781
 hypern/response/__init__.py,sha256=9z99BDgASpG404GK8LGkOsXgac0wFwH_cQOTI5Ju-1U,223
 hypern/response/response.py,sha256=s6KqscjA7jl8RaZh5gZQgVksPtHKzsRrQywDcEjVSR4,4448
+hypern/reload.py,sha256=oRwDyxze69ERiVT41eJI_qpg6eJFDbIszGPVAoS5DHs,2233
 hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/auth/authorization.py,sha256=b8N_MiBmSJBVR45SsOI2iMGmXYOlNKbsMsrMwXApxtk,30
 hypern/security.py,sha256=dOWdNHA8SoUhlbu6Z2MapOwT9tAhlsierrTBBiEV5-A,1729
@@ -20,9 +21,9 @@ hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/openapi/swagger.py,sha256=E5fHYUfFa77zQsCyQGf_vnqJVpl4_KI5qsKFHdgJEdw,61
 hypern/openapi/__init__.py,sha256=oJ0HM9yAgSN00mBC_fRgV2irlGugrhvIpiveuDMv8PM,136
 hypern/openapi/schemas.py,sha256=nmcmNYvKmjNkwFqi_3qpXVi1ukanNxMVay68bOLTrx8,1624
-hypern/application.py,sha256=fZ4pXSLHuJO7hyIq3THFnNDfpXJt3p5IxYYYgmOBNXU,14771
+hypern/application.py,sha256=DE9tQjkB4Pa6YQmmKJ7QwdaHDnhW3iw99zsyLJ0uFLI,13018
 hypern/hypern.pyi,sha256=eSqxlY7q6KboRjP3bpRlGSn2sEjxrIHFpxXh1o-qQJ4,6649
-hypern/processpool.py,sha256=q985ILIzI7CSiusRL614PwOAT4RCczon7e-CAn1U5Vc,2925
+hypern/processpool.py,sha256=Wrh_l87-3w4Z9znc6P22hi8kZfBA8cQ1C0Oaq8ysLVs,3657
 hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/db/nosql/addons/color.py,sha256=8zUBFjR19J1zy_WaOCXlS14GjgdOaHAcuSb__zFp_II,430
 hypern/db/nosql/addons/unicode.py,sha256=vKyqfzrS9SKFo4eKlvu6klST0FrjM0wTx5N3ocvSSO8,258
@@ -44,6 +45,7 @@ hypern/db/sql/repository.py,sha256=YShEl1DqRXtYwNnn1F3YVfXX-TEdoNRjDEWIO_3Lu2s,9
 hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/exceptions.py,sha256=wpTSTzw32Sb6bY9YxCDM7W_-Ww6u6pB1GKNbFf-1oj0,2331
 hypern/scheduler.py,sha256=nQoWIYMRmKd30g4XwdB072hWTNHvJlLd9S6rLlTFKS0,62
+hypern/args_parser.py,sha256=kJQtzw2xZrumDBzLQaZyEejAT02rUetPYCrmOpjzxWY,1731
 hypern/routing/dispatcher.py,sha256=aujogCVTz2mYtZRkEtmpdlxXA9l6X4D072qOiIg-a_Q,2301
 hypern/routing/route.py,sha256=ribSMOo0eZ2WUZ1P8PdiXIsyVA3dHrI1gEYDikRDn4o,10090
 hypern/routing/__init__.py,sha256=MtyPYRHYMWIiCReZsUjJH93PvluotCbPU3RnWFQQmrA,97
@@ -61,6 +63,6 @@ hypern/caching/base/__init__.py,sha256=8S6QSax1FVGzfve_fYIzPmhrpvxXG8WYoc7M9v25b
 hypern/caching/base/key_maker.py,sha256=FPW9L-N8NSPPgRngqMUCOdLurm1qmqe-KTe4UctoBp8,224
 hypern/caching/redis_backend.py,sha256=3FYzKCW0_OvoIMl-e9pARRGOUvRYGG7hGlaXEB18vnY,67
 hypern/logging/__init__.py,sha256=lzYSz0382eIM3CvP0sZ6RbEEwYZwfeJEJh9cxQA6Rws,49
-hypern/logging/logger.py,sha256=hYOLjx_UVdnaDLFnmCZMANx3rgs4TIGsvtBFJ-YlYxg,3174
-hypern/hypern.cpython-312-darwin.so,sha256=Jmq4KRpvCWhQVPosdgqXkBQ2aQ_NLBtJS8cfoWfMUjg,6094016
-hypern-0.2.0.dist-info/RECORD,,
+hypern/logging/logger.py,sha256=62Qg4YAi_JDGV72Rd6R58jixqZk7anRqHbtnuBlkrwA,3174
+hypern/hypern.cpython-312-darwin.so,sha256=xj9wejpm2gopjNG_OyY66_FUGk5KI-Tpwr0YiPfQ3n8,6094040
+hypern-0.2.1.dist-info/RECORD,,