Refactor code

Author: sansyrox

integration_tests/base_routes.py

@@ -43,8 +43,9 @@ async def hello(request):
     global callCount
     callCount += 1
     message = "Called " + str(callCount) + " times"
-    print(message)
-    return jsonify(request)
+    print(message, request)
+    return {"status_code": "200", "body": "hello", "type": "text"}
+    # return 
 
 
 @app.before_request("/")

robyn/__init__.py

@@ -13,6 +13,7 @@
 from .processpool import spawn_process
 from .log_colors import Colors
 from .ws import WS
+from .router import Router, MiddlewareRouter, WebSocketRouter
 
 # 3rd party imports and exports
 from multiprocess import Process
@@ -32,11 +33,10 @@ def __init__(self, file_object):
         self.dev = self.parser.is_dev()
         self.processes = self.parser.num_processes()
         self.workers = self.parser.workers()
-        self.routes = []
+        self.router = Router()
+        self.middleware_router = MiddlewareRouter()
+        self.web_socket_router = WebSocketRouter()
         self.headers = []
-        self.routes = []
-        self.middlewares = []
-        self.web_sockets = {}
         self.directories = []
         self.event_handlers = {}
 
@@ -51,133 +51,23 @@ def add_route(self, route_type, endpoint, handler):
 
         """ We will add the status code here only
         """
-        async def async_inner_handler(*args):
-            res = await handler(args)
-            if type(res) == "dict":
-                if "status_code" not in res:
-                    res["status_code"] = "200"
-            else:
-                response = {
-                    "status_code": "200",
-                    "body": res,
-                    "type": "text"
-                }
-                res = response
-            return res
-
-        def inner_handler(*args):
-            res = handler(args)
-            if type(res) == "dict":
-                if "status_code" not in res:
-                    res["status_code"] = 200
-            else:
-                response = {
-                    "status_code": 200,
-                    "body": res,
-                    "type": "text"
-                }
-                res = response
-            return res
-
-        number_of_params = len(signature(handler).parameters)
-        if asyncio.iscoroutinefunction(handler):
-            self.routes.append(
-                (
-                    route_type,
-                    endpoint,
-                    async_inner_handler,
-                    True,
-                    number_of_params,
-                )
-            )
-        else:
-            self.routes.append(
-                (
-                    route_type,
-                    endpoint,
-                    inner_handler,
-                    False,
-                    number_of_params,
-                )
-            )
-
-    def add_middleware_route(self, route_type, endpoint, handler):
-        """
-        [This is base handler for the middleware decorator]
-
-        :param route_type [str]: [??]
-        :param endpoint [str]: [endpoint for the route added]
-        :param handler [function]: [represents the sync or async function passed as a handler for the route]
-        """
-
-        """ We will add the status code here only
-        """
-        number_of_params = len(signature(handler).parameters)
-        self.middlewares.append(
-            (
-                route_type,
-                endpoint,
-                handler,
-                asyncio.iscoroutinefunction(handler),
-                number_of_params,
-            )
-        )
+        self.router.add_route(route_type, endpoint, handler)
 
     def before_request(self, endpoint):
         """
         [The @app.before_request decorator to add a get route]
 
         :param endpoint [str]: [endpoint to server the route]
         """
-
-        # This inner function is basically a wrapper arround the closure(decorator) 
-        # being returned.
-        # It takes in a handler and converts it in into a closure
-        # and returns the arguments. 
-        # Arguments are returned as they could be modified by the middlewares.
-        def inner(handler):
-            async def async_inner_handler(*args):
-                await handler(args)
-                return args
-
-            def inner_handler(*args):
-                handler(*args)
-                return args
-
-            if asyncio.iscoroutinefunction(handler):
-                self.add_middleware_route("BEFORE_REQUEST", endpoint, async_inner_handler)
-            else:
-                self.add_middleware_route("BEFORE_REQUEST", endpoint, inner_handler)
-
-        return inner
+        return self.middleware_router.add_before_request(endpoint)
 
     def after_request(self, endpoint):
         """
         [The @app.after_request decorator to add a get route]
 
         :param endpoint [str]: [endpoint to server the route]
         """
-
-        # This inner function is basically a wrapper arround the closure(decorator) 
-        # being returned.
-        # It takes in a handler and converts it in into a closure
-        # and returns the arguments. 
-        # Arguments are returned as they could be modified by the middlewares.
-        def inner(handler):
-            async def async_inner_handler(*args):
-                await handler(args)
-                return args
-
-            def inner_handler(*args):
-                handler(*args)
-                return args
-
-            if asyncio.iscoroutinefunction(handler):
-                self.add_middleware_route("AFTER_REQUEST", endpoint, async_inner_handler)
-            else:
-                self.add_middleware_route("AFTER_REQUEST", endpoint, inner_handler)
-
-        return inner
+        return self.middleware_router.add_after_request(endpoint)
 
     def add_directory(
         self, route, directory_path, index_file=None, show_files_listing=False
@@ -188,7 +78,7 @@ def add_header(self, key, value):
         self.headers.append((key, value))
 
     def add_web_socket(self, endpoint, ws):
-        self.web_sockets[endpoint] = ws
+        self.web_socket_router.add_route(endpoint, ws)
 
     def _add_event_handler(self, event_type: str, handler):
         print(f"Add event {event_type} handler")
@@ -213,17 +103,16 @@ def start(self, url="127.0.0.1", port=5000):
         if not self.dev:
             workers = self.workers
             socket = SocketHeld(url, port)
-            print(self.middlewares)
             for _ in range(self.processes):
                 copied_socket = socket.try_clone()
                 p = Process(
                     target=spawn_process,
                     args=(
                         self.directories,
                         self.headers,
-                        self.routes,
-                        self.middlewares,
-                        self.web_sockets,
+                        self.router.get_routes(),
+                        self.middleware_router.get_routes(),
+                        self.web_socket_router.get_routes(),
                         self.event_handlers,
                         copied_socket,
                         workers,

robyn/router.py

@@ -0,0 +1,144 @@
+from abc import ABC, abstractmethod
+from inspect import signature
+from asyncio import iscoroutinefunction
+
+
+class BaseRouter(ABC):
+    @abstractmethod
+    def add_route(*args):
+        ...
+
+
+class Router(BaseRouter):
+    def __init__(self) -> None:
+        super().__init__()
+        self.routes = []
+
+    def _format_response(self, res):
+        # handle file handlers
+        response = {}
+        if type(res) == dict:
+            if "status_code" not in res:
+                print("Getting here")
+                res["status_code"] = "200"
+                response = res
+            else:
+                response = {
+                    "status_code": "200",
+                    "body": res["body"],
+                    "type": "text",
+                }
+            print("Setting the response", response)
+        else:
+            response = {"status_code": "200", "body": res, "type": "text"}
+
+        return response
+
+    def add_route(self, route_type, endpoint, handler):
+        async def async_inner_handler(*args):
+            response = self._format_response(await handler(*args))
+            print(f"This is the response in python: {response}")
+            return response
+
+        def inner_handler(*args):
+            response = self._format_response(handler(*args))
+            return response
+
+        number_of_params = len(signature(handler).parameters)
+        if iscoroutinefunction(handler):
+            self.routes.append(
+                (
+                    route_type,
+                    endpoint,
+                    async_inner_handler,
+                    True,
+                    number_of_params,
+                )
+            )
+        else:
+            self.routes.append(
+                (
+                    route_type,
+                    endpoint,
+                    inner_handler,
+                    False,
+                    number_of_params,
+                )
+            )
+
+        self.routes.append((route_type, endpoint, handler))
+
+    def get_routes(self):
+        return self.routes
+
+
+class MiddlewareRouter(BaseRouter):
+    def __init__(self) -> None:
+        super().__init__()
+        self.routes = []
+
+    def add_route(self, route_type, endpoint, handler):
+        number_of_params = len(signature(handler).parameters)
+        self.routes.append(
+            (
+                route_type,
+                endpoint,
+                handler,
+                iscoroutinefunction(handler),
+                number_of_params,
+            )
+        )
+
+    # These inner function is basically a wrapper arround the closure(decorator)
+    # being returned.
+    # It takes in a handler and converts it in into a closure
+    # and returns the arguments.
+    # Arguments are returned as they could be modified by the middlewares.
+    def add_after_request(self, endpoint):
+        def inner(handler):
+            async def async_inner_handler(*args):
+                await handler(args)
+                return args
+
+            def inner_handler(*args):
+                handler(*args)
+                return args
+
+            if iscoroutinefunction(handler):
+                self.add_route("AFTER_REQUEST", endpoint, async_inner_handler)
+            else:
+                self.add_route("AFTER_REQUEST", endpoint, inner_handler)
+
+        return inner
+
+    def add_before_request(self, endpoint):
+        def inner(handler):
+            async def async_inner_handler(*args):
+                await handler(args)
+                return args
+
+            def inner_handler(*args):
+                handler(*args)
+                return args
+
+            if iscoroutinefunction(handler):
+                self.add_route("BEFORE_REQUEST", endpoint, async_inner_handler)
+            else:
+                self.add_route("BEFORE_REQUEST", endpoint, inner_handler)
+
+        return inner
+
+    def get_routes(self):
+        return self.routes
+
+
+class WebSocketRouter(BaseRouter):
+    def __init__(self) -> None:
+        super().__init__()
+        self.routes = {}
+
+    def add_route(self, endpoint, web_socket):
+        self.routes[endpoint] = web_socket
+
+    def get_routes(self):
+        return self.routes

src/processor.rs

@@ -278,6 +278,8 @@ async fn execute_http_function(
 
             let output = output.await?;
             let res = Python::with_gil(|py| -> PyResult<HashMap<String, String>> {
+                println!("This is the result of the code {:?}", output);
+
                 let res: HashMap<String, String> =
                     output.into_ref(py).downcast::<PyDict>()?.extract()?;
                 Ok(res)