hypern 0.2.0__cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl → 0.3.0__cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.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.hypern import FunctionInfo, Router, Route as InternalRoute, WebsocketRouter
 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
+from hypern.ws import WebsocketRoute
 
 AppType = TypeVar("AppType", bound="Hypern")
 
@@ -49,6 +47,15 @@ class Hypern:
                 """
             ),
         ] = None,
+        websockets: Annotated[
+            List[WebsocketRoute] | None,
+            Doc(
+                """
+                A list of routes to serve incoming WebSocket requests.
+                You can define routes using the `WebsocketRoute` class from `Hypern
+                """
+            ),
+        ] = None,
         title: Annotated[
             str,
             Doc(
@@ -188,15 +195,20 @@ class Hypern:
     ) -> None:
         super().__init__(*args, **kwargs)
         self.router = Router(path="/")
+        self.websocket_router = WebsocketRouter(path="/")
         self.scheduler = scheduler
         self.injectables = default_injectables or {}
         self.middleware_before_request = []
         self.middleware_after_request = []
         self.response_headers = {}
+        self.args = ArgsConfig()
 
-        for route in routes:
+        for route in routes or []:
             self.router.extend_route(route(app=self).routes)
 
+        for websocket_route in websockets or []:
+            self.websocket_router.add_route(websocket_route)
+
         if openapi_url and docs_url:
             self.__add_openapi(
                 info=Info(
@@ -340,60 +352,31 @@ 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,
+            websocket_router=self.websocket_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]):
@@ -410,3 +393,13 @@ class Hypern:
         func_info = FunctionInfo(handler=handler, is_async=is_async)
         route = InternalRoute(path=endpoint, function=func_info, method=method.name)
         self.router.add_route(route=route)
+
+    def add_websocket(self, ws_route: WebsocketRoute):
+        """
+        Adds a WebSocket route to the WebSocket router.
+
+        Args:
+            ws_route (WebsocketRoute): The WebSocket route to be added to the router.
+        """
+        for route in ws_route.routes:
+            self.websocket_router.add_route(route=route)

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/hypern.pyi

@@ -183,9 +183,6 @@ class FunctionInfo:
     handler: Callable
     is_async: bool
 
-class SocketHeld:
-    socket: Any
-
 @dataclass
 class Server:
     router: Router
@@ -195,6 +192,7 @@ class Server:
 
     def add_route(self, route: Route) -> None: ...
     def set_router(self, router: Router) -> None: ...
+    def set_websocket_router(self, websocket_router: WebsocketRouter) -> None: ...
     def start(self, socket: SocketHeld, worker: int, max_blocking_threads: int) -> None: ...
     def inject(self, key: str, value: Any) -> None: ...
     def set_injected(self, injected: Dict[str, Any]) -> None: ...
@@ -227,6 +225,34 @@ class Router:
     def get_routes_by_method(self, method: str) -> List[Route]: ...
     def extend_route(self, routes: List[Route]) -> None: ...
 
+@dataclass
+class SocketHeld:
+    socket: Any
+
+@dataclass
+class WebSocketSession:
+    sender: Callable[[str], None]
+    receiver: Callable[[], str]
+    is_closed: bool
+
+    def send(self, message: str) -> None: ...
+
+@dataclass
+class WebsocketRoute:
+    path: str
+    handler: Callable[[WebSocketSession], None]
+
+@dataclass
+class WebsocketRouter:
+    path: str
+    routes: List[WebsocketRoute]
+
+    def add_route(self, route: WebsocketRoute) -> None: ...
+    def remove_route(self, path: str) -> None: ...
+    def extend_route(self, route: WebsocketRoute) -> None: ...
+    def clear_routes(self) -> None: ...
+    def route_count(self) -> int: ...
+
 @dataclass
 class Header:
     headers: Dict[str, str]
@@ -264,3 +290,6 @@ class Request:
     path_params: Dict[str, str]
     body: BodyData
     method: str
+    remote_addr: str
+    timestamp: float
+    context_id: str

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/middleware/limit.py

@@ -147,7 +147,7 @@ class ConcurrentRequestMiddleware(Middleware):
         self.lock = Lock()
 
     def get_request_identifier(self, request):
-        return request.ip_addr
+        return request.remote_addr
 
     def before_request(self, request):
         """

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 .hypern import FunctionInfo, Router, Server, SocketHeld, WebsocketRouter
 from .logging import logger
+from .reload import EventHandler
 
 
 def run_processes(
@@ -16,14 +19,18 @@ def run_processes(
     processes: int,
     max_blocking_threads: int,
     router: Router,
+    websocket_router: WebsocketRouter,
     injectables: Dict[str, Any],
     before_request: List[FunctionInfo],
     after_request: List[FunctionInfo],
     response_headers: Dict[str, str],
+    reload: bool = True,
 ) -> List[Process]:
     socket = SocketHeld(host, port)
 
-    process_pool = init_processpool(router, socket, workers, processes, max_blocking_threads, injectables, before_request, after_request, response_headers)
+    process_pool = init_processpool(
+        router, websocket_router, socket, workers, processes, max_blocking_threads, injectables, before_request, after_request, response_headers
+    )
 
     def terminating_signal_handler(_sig, _frame):
         logger.info("Terminating server!!")
@@ -33,15 +40,37 @@ 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
 
 
 def init_processpool(
     router: Router,
+    websocket_router: WebsocketRouter,
     socket: SocketHeld,
     workers: int,
     processes: int,
@@ -57,7 +86,7 @@ def init_processpool(
         copied_socket = socket.try_clone()
         process = Process(
             target=spawn_process,
-            args=(router, copied_socket, workers, max_blocking_threads, injectables, before_request, after_request, response_headers),
+            args=(router, websocket_router, copied_socket, workers, max_blocking_threads, injectables, before_request, after_request, response_headers),
         )
         process.start()
         process_pool.append(process)
@@ -81,6 +110,7 @@ def initialize_event_loop():
 
 def spawn_process(
     router: Router,
+    websocket_router: WebsocketRouter,
     socket: SocketHeld,
     workers: int,
     max_blocking_threads: int,
@@ -93,6 +123,7 @@ def spawn_process(
 
     server = Server()
     server.set_router(router=router)
+    server.set_websocket_router(websocket_router=websocket_router)
     server.set_injected(injected=injectables)
     server.set_before_hooks(hooks=before_request)
     server.set_after_hooks(hooks=after_request)

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/routing/route.py

@@ -188,7 +188,7 @@ class Route:
             docs["responses"] = {
                 "200": {
                     "description": "Successful response",
-                    "content": {"application/json": {"schema": response_type.model_json_schema()}},
+                    "content": {"application/json": {"schema": pydantic_to_swagger(response_type).get(response_type.__name__)}},
                 }
             }
 

hypern/ws.py

@@ -0,0 +1,16 @@
+from .hypern import WebsocketRoute as WebsocketRouteInternal, WebSocketSession
+
+
+class WebsocketRoute:
+    def __init__(self) -> None:
+        self.routes = []
+
+    def on(self, path):
+        def wrapper(func):
+            self.routes.append(WebsocketRouteInternal(path, func))
+            return func
+
+        return wrapper
+
+
+__all__ = ["WebsocketRoute", "WebSocketSession"]

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: hypern
-Version: 0.2.0
+Version: 0.3.0
 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.3.0.dist-info}/RECORD

@@ -1,25 +1,27 @@
-hypern-0.2.0.dist-info/METADATA,sha256=vr_oCiPq5bDdIyTt0w6S_phtY8IvEX-oRW407K-Wd-o,3626
-hypern-0.2.0.dist-info/WHEEL,sha256=o8sInZVN8vcuWYVPD-pUpJuGZk9YuD70jVvxGoQg6-0,125
-hypern-0.2.0.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
-hypern/application.py,sha256=fZ4pXSLHuJO7hyIq3THFnNDfpXJt3p5IxYYYgmOBNXU,14771
+hypern-0.3.0.dist-info/METADATA,sha256=SINnZRpXUXjLnonzyUZ-STXzjY1JRGPl_nu0vqF0Qkg,3658
+hypern-0.3.0.dist-info/WHEEL,sha256=IVSFWXFWSEs2jwzqcaXi10esovSNujWh380jSRKxYz0,125
+hypern-0.3.0.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
+hypern/application.py,sha256=yXrKhVKwCQDweHoZPFyWr0ws7nmCOPp6H3aLZLbD7sw,13923
 hypern/middleware/__init__.py,sha256=YpgxL7GQkzZM91VCNxHT2xmTa1R1b_BUS8n3tZ2b1Ys,268
 hypern/middleware/cors.py,sha256=SfG-3vAS-4MPXqsIsegNwDx9mqC9lvgUc3RuYzN6HNg,1643
 hypern/middleware/base.py,sha256=Llcg9wglcumvY4BqaTfrX1OOZDqns4wb34wGF55EXcI,523
-hypern/middleware/limit.py,sha256=JNlZ2S5xlr3svt_rvr92ofh_zsVpe1uNuGc2jO5y3GY,7972
+hypern/middleware/limit.py,sha256=9EA79q2GgyZkRynMJj8rfgumEhJKbAvyi3jII6A_BX8,7976
 hypern/middleware/i18n.py,sha256=s82nQo6kKClZ0s3G3jsy87VRfwxpBDbASB_ErjRL3O0,15
 hypern/routing/dispatcher.py,sha256=aujogCVTz2mYtZRkEtmpdlxXA9l6X4D072qOiIg-a_Q,2301
 hypern/routing/__init__.py,sha256=MtyPYRHYMWIiCReZsUjJH93PvluotCbPU3RnWFQQmrA,97
-hypern/routing/route.py,sha256=ribSMOo0eZ2WUZ1P8PdiXIsyVA3dHrI1gEYDikRDn4o,10090
+hypern/routing/route.py,sha256=AZc4Qo5iy74q0_U8E5X6RIsudznHZYEZR8MdHRoCmB4,10119
 hypern/routing/endpoint.py,sha256=AWLHLQNlSGR8IGU6xM0RP-1kP06OJQzqpbXKSiZEzEo,996
 hypern/routing/parser.py,sha256=4BFn8MAmSX1QplwBXEEgbabYiNUAllYf2svPZoPPD5k,3454
 hypern/response/__init__.py,sha256=9z99BDgASpG404GK8LGkOsXgac0wFwH_cQOTI5Ju-1U,223
 hypern/response/response.py,sha256=s6KqscjA7jl8RaZh5gZQgVksPtHKzsRrQywDcEjVSR4,4448
 hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hypern/processpool.py,sha256=q985ILIzI7CSiusRL614PwOAT4RCczon7e-CAn1U5Vc,2925
+hypern/ws.py,sha256=XImBSYW2SM9s8wprnis8c2uRPhYxIXuDhwgRLLLDU38,378
+hypern/processpool.py,sha256=mtP6qYSKTUgHOQEqtw6yhBvZ4JMAPw6uLxuyd-96CYI,3908
 hypern/security.py,sha256=dOWdNHA8SoUhlbu6Z2MapOwT9tAhlsierrTBBiEV5-A,1729
-hypern/hypern.pyi,sha256=eSqxlY7q6KboRjP3bpRlGSn2sEjxrIHFpxXh1o-qQJ4,6649
-hypern/logging/logger.py,sha256=hYOLjx_UVdnaDLFnmCZMANx3rgs4TIGsvtBFJ-YlYxg,3174
+hypern/hypern.pyi,sha256=WlE2tNIY3FnJaUorHKfJ7tY-DZf83XK7bRvzrxauyr4,7405
+hypern/logging/logger.py,sha256=62Qg4YAi_JDGV72Rd6R58jixqZk7anRqHbtnuBlkrwA,3174
 hypern/logging/__init__.py,sha256=lzYSz0382eIM3CvP0sZ6RbEEwYZwfeJEJh9cxQA6Rws,49
+hypern/reload.py,sha256=oRwDyxze69ERiVT41eJI_qpg6eJFDbIszGPVAoS5DHs,2233
 hypern/exceptions.py,sha256=wpTSTzw32Sb6bY9YxCDM7W_-Ww6u6pB1GKNbFf-1oj0,2331
 hypern/openapi/schemas.py,sha256=nmcmNYvKmjNkwFqi_3qpXVi1ukanNxMVay68bOLTrx8,1624
 hypern/openapi/__init__.py,sha256=oJ0HM9yAgSN00mBC_fRgV2irlGugrhvIpiveuDMv8PM,136
@@ -39,6 +41,7 @@ hypern/caching/redis_backend.py,sha256=3FYzKCW0_OvoIMl-e9pARRGOUvRYGG7hGlaXEB18v
 hypern/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/caching/custom_key_maker.py,sha256=DxJv1RV--5IdFCCFYawVExwMQ097hZ5V6_nHDYIQIZI,383
 hypern/caching/cache_manager.py,sha256=EBx89xNj38bYpQ9jf4MoQ3zNkfoCGYInxvvPtzsW5Xo,1997
+hypern/args_parser.py,sha256=kJQtzw2xZrumDBzLQaZyEejAT02rUetPYCrmOpjzxWY,1731
 hypern/enum.py,sha256=-StRU0cWboP-y5fNuhB4Q7yMk8Zm_h1Eua9KzOtIyI8,347
 hypern/worker.py,sha256=kN93QGx4bst0inHRO_fsTzMmhDA0N3pdzaqNXwyu3N0,894
 hypern/db/nosql/__init__.py,sha256=LCVBhcJCQmFt5dCLiSf7C_TsjsEILeZe8JqiFEKuD2s,619
@@ -62,5 +65,5 @@ hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/datastructures.py,sha256=7Nb_fOxmfO8CT7_v_-RhmXg54IhioXGZSp405IzJLh4,857
 hypern/config.py,sha256=v9KLL6snReAETKiVb8x3KOFrXpYd8-Io5tM7eruR85U,4781
 hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hypern/hypern.cpython-312-i386-linux-gnu.so,sha256=g5_ahAIXUIFfyFOMu72jvU__BrPnMBRqlyy6wqCEft8,6258556
-hypern-0.2.0.dist-info/RECORD,,
+hypern/hypern.cpython-312-i386-linux-gnu.so,sha256=q6UBGw9RKhwgvnPcD-hRHsPGvrhbv2FDio_k74iZ-oo,6504596
+hypern-0.3.0.dist-info/RECORD,,

{hypern-0.2.0.dist-info → hypern-0.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.7.4)
+Generator: maturin (1.7.7)
 Root-Is-Purelib: false
 Tag: cp312-cp312-manylinux_2_12_i686.manylinux2010_i686