fix: introduce PyRequest and PyResponse struct

Author: AntoineRR

integration_tests/base_routes.py

@@ -57,17 +57,13 @@ def shutdown_handler():
 
 @app.before_request("/sync/middlewares")
 def sync_before_request(request: Request):
-    new_headers = request.headers
-    new_headers["before"] = "sync_before_request"
-    request.headers = new_headers
+    request.headers["before"] = "sync_before_request"
     return request
 
 
 @app.after_request("/sync/middlewares")
 def sync_after_request(response: Response):
-    new_headers = response.headers
-    new_headers["after"] = "sync_after_request"
-    response.headers = new_headers
+    response.headers["after"] = "sync_after_request"
     response.body = response.body + " after"
     return response
 
@@ -81,17 +77,13 @@ def sync_middlewares(request: Request):
 
 @app.before_request("/async/middlewares")
 async def async_before_request(request: Request):
-    new_headers = request.headers
-    new_headers["before"] = "async_before_request"
-    request.headers = new_headers
+    request.headers["before"] = "async_before_request"
     return request
 
 
 @app.after_request("/async/middlewares")
 async def async_after_request(response: Response):
-    new_headers = response.headers
-    new_headers["after"] = "async_after_request"
-    response.headers = new_headers
+    response.headers["after"] = "async_after_request"
     response.body = response.body + " after"
     return response
 

integration_tests/test_middlewares.py

@@ -7,6 +7,8 @@
 @pytest.mark.parametrize("function_type", ["sync", "async"])
 def test_middlewares(function_type: str, session):
     r = get(f"/{function_type}/middlewares")
+    # We do not want the request headers to be in the response
+    assert "before" not in r.headers
     assert "after" in r.headers
     assert r.headers["after"] == f"{function_type}_after_request"
     assert r.text == f"{function_type} middlewares after"

robyn/robyn.pyi

@@ -15,30 +15,21 @@ class FunctionInfo:
     is_async: bool
     number_of_params: int
 
-@dataclass
-class Body:
-    content: Union[str, bytes]
-
-    def as_bytes(self) -> bytes:
-        pass
-    def set(self, content: Union[str, bytes]):
-        pass
-
 @dataclass
 class Request:
     queries: dict[str, str]
     headers: dict[str, str]
     params: dict[str, str]
-    body: Body
+    body: Union[str, bytes]
+    method: str
 
 @dataclass
 class Response:
     status_code: int
+    response_type: str
     headers: dict[str, str]
-    body: Body
-
-    def set_file_path(self, file_path: str):
-        pass
+    body: Union[str, bytes]
+    file_path: str
 
 class Server:
     def __init__(self) -> None:

robyn/router.py

@@ -37,7 +37,7 @@ def _format_response(self, res):
             response = Response(status_code=status_code, headers=headers, body=body)
             file_path = res.get("file_path")
             if file_path is not None:
-                response.set_file_path(file_path)
+                response.file_path = file_path
         elif isinstance(res, Response):
             response = res
         elif isinstance(res, bytes):

src/executors/mod.rs

@@ -1,55 +1,56 @@
 /// This is the module that has all the executor functions
 /// i.e. the functions that have the responsibility of parsing and executing functions.
-use crate::types::{FunctionInfo, Request, Response};
-
 use std::sync::Arc;
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use log::debug;
+use pyo3::prelude::*;
 use pyo3_asyncio::TaskLocals;
-// pyO3 module
-use pyo3::{prelude::*, PyClass};
+
+use crate::types::{function_info::FunctionInfo, request::Request, response::Response};
 
 fn get_function_output<'a, T>(
     function: &'a FunctionInfo,
     py: Python<'a>,
     input: &T,
 ) -> Result<&'a PyAny, PyErr>
 where
-    T: Clone + IntoPy<Py<PyAny>>,
+    T: ToPyObject,
 {
     let handler = function.handler.as_ref(py);
 
     // this makes the request object accessible across every route
     match function.number_of_params {
         0 => handler.call0(),
-        1 => handler.call1((input.clone(),)),
+        1 => handler.call1((input.to_object(py),)),
         // this is done to accommodate any future params
-        2_u8..=u8::MAX => handler.call1((input.clone(),)),
+        2_u8..=u8::MAX => handler.call1((input.to_object(py),)),
     }
 }
 
-pub async fn execute_middleware_function<'a, T>(input: &T, function: FunctionInfo) -> Result<T>
+pub async fn execute_middleware_function<T>(input: &T, function: FunctionInfo) -> Result<T>
 where
-    T: Clone + PyClass + IntoPy<Py<PyAny>>,
+    T: for<'a> FromPyObject<'a> + ToPyObject,
 {
     if function.is_async {
-        let output = Python::with_gil(|py| {
+        let output: Py<PyAny> = Python::with_gil(|py| {
             pyo3_asyncio::tokio::into_future(get_function_output(&function, py, input)?)
         })?
         .await?;
 
-        Python::with_gil(|py| -> PyResult<T> {
-            let output: (T,) = output.extract(py)?;
+        Python::with_gil(|py| -> Result<T> {
+            let output: (T,) = output
+                .extract(py)
+                .context("Failed to get middleware response")?;
             Ok(output.0)
         })
-        .map_err(|e| anyhow!(e))
     } else {
-        Python::with_gil(|py| -> PyResult<T> {
-            let output: (T,) = get_function_output(&function, py, input)?.extract()?;
+        Python::with_gil(|py| -> Result<T> {
+            let output: (T,) = get_function_output(&function, py, input)?
+                .extract()
+                .context("Failed to get middleware response")?;
             Ok(output.0)
         })
-        .map_err(|e| anyhow!(e))
     }
 }
 
@@ -67,8 +68,9 @@ pub async fn execute_http_function(request: &Request, function: FunctionInfo) ->
         })
     } else {
         Python::with_gil(|py| -> Result<Response> {
-            let output = get_function_output(&function, py, request)?;
-            output.extract().context("Failed to get route response")
+            get_function_output(&function, py, request)?
+                .extract()
+                .context("Failed to get route response")
         })
     }
 }

src/lib.rs

@@ -11,17 +11,16 @@ use shared_socket::SocketHeld;
 
 // pyO3 module
 use pyo3::prelude::*;
-use types::{ActixBytesWrapper, FunctionInfo, Request, Response};
+use types::{function_info::FunctionInfo, request::PyRequest, response::PyResponse};
 
 #[pymodule]
 pub fn robyn(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     // the pymodule class to make the rustPyFunctions available
     m.add_class::<Server>()?;
     m.add_class::<SocketHeld>()?;
     m.add_class::<FunctionInfo>()?;
-    m.add_class::<Request>()?;
-    m.add_class::<Response>()?;
-    m.add_class::<ActixBytesWrapper>()?;
+    m.add_class::<PyRequest>()?;
+    m.add_class::<PyResponse>()?;
     pyo3::prepare_freethreaded_python();
     Ok(())
 }

src/routers/const_router.rs

@@ -4,8 +4,9 @@ use std::sync::Arc;
 use std::sync::RwLock;
 
 use crate::executors::execute_http_function;
-use crate::types::Response;
-use crate::types::{FunctionInfo, Request};
+use crate::types::function_info::FunctionInfo;
+use crate::types::request::Request;
+use crate::types::response::Response;
 use anyhow::Context;
 use log::debug;
 use matchit::Router as MatchItRouter;

src/routers/http_router.rs

@@ -1,15 +1,14 @@
 use std::sync::RwLock;
 use std::{collections::HashMap, str::FromStr};
-// pyo3 modules
-use crate::types::FunctionInfo;
-use pyo3::types::PyAny;
 
 use actix_web::http::Method;
 use matchit::Router as MatchItRouter;
+use pyo3::types::PyAny;
 
 use anyhow::{Context, Result};
 
 use super::Router;
+use crate::types::function_info::FunctionInfo;
 
 type RouteMap = RwLock<MatchItRouter<FunctionInfo>>;
 

src/routers/middleware_router.rs

@@ -1,14 +1,12 @@
 use std::collections::HashMap;
 use std::sync::RwLock;
-// pyo3 modules
-use crate::types::FunctionInfo;
+
 use anyhow::{Context, Error, Result};
 use matchit::Router as MatchItRouter;
 use pyo3::types::PyAny;
 
-use crate::routers::types::MiddlewareRoute;
-
 use super::Router;
+use crate::{routers::types::MiddlewareRoute, types::function_info::FunctionInfo};
 
 type RouteMap = RwLock<MatchItRouter<FunctionInfo>>;
 

src/routers/mod.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use pyo3::PyAny;
 
-use crate::types::FunctionInfo;
+use crate::types::function_info::FunctionInfo;
 
 pub mod const_router;
 pub mod http_router;

src/routers/web_socket_router.rs

@@ -1,11 +1,11 @@
 use std::collections::HashMap;
 use std::sync::RwLock;
-// pyo3 modules
-use crate::types::FunctionInfo;
+
 use log::debug;
 
-/// Contains the thread safe hashmaps of different routes
+use crate::types::function_info::FunctionInfo;
 
+/// Contains the thread safe hashmaps of different routes
 type WebSocketRoutes = RwLock<HashMap<String, HashMap<String, FunctionInfo>>>;
 
 pub struct WebSocketRouter {

src/server.rs

@@ -1,5 +1,4 @@
 use crate::executors::{execute_event_handler, execute_http_function, execute_middleware_function};
-use crate::types::{Request, Response};
 
 use crate::routers::const_router::ConstRouter;
 use crate::routers::Router;
@@ -8,7 +7,9 @@ use crate::routers::http_router::HttpRouter;
 use crate::routers::types::MiddlewareRoute;
 use crate::routers::{middleware_router::MiddlewareRouter, web_socket_router::WebSocketRouter};
 use crate::shared_socket::SocketHeld;
-use crate::types::FunctionInfo;
+use crate::types::function_info::FunctionInfo;
+use crate::types::request::Request;
+use crate::types::response::Response;
 use crate::web_socket_connection::start_web_socket;
 
 use std::convert::TryInto;