support return type with raw type

Author: ponytailer

README.md

@@ -72,6 +72,16 @@ class MyAPIClient(RequestsWebClient):
     def create_user(self, user: CreateUser) -> UserResponse:
         pass
 
+    @get("/users/string)
+    def get_user_string(self, user_id: str) -> dict:
+        # will get raw json data
+        ...
+    
+    @get("/users/bytes")
+    def get_user_bytes(self, user_id: str) -> bytes:
+        # will get raw content, bytes type.
+        ...
+
     @delete("/users", agno_tool=True, tool_description="this is the function to delete user")
     def delete_user(self, user_id: str, request_headers: Dict[str, Any]):
         ...

pydantic_client/async_client.py

@@ -36,11 +36,14 @@ async def _request(self, request_info: RequestInfo) -> Any:
                 timeout=aiohttp.ClientTimeout(total=self.timeout)
             ) as response:
                 response.raise_for_status()
-                data = await response.json()
 
-                if response_model is not None:
-                    return response_model.model_validate(data, from_attributes=True)
-                return data
+                if response_model is str:
+                    return await response.text()
+                elif response_model is bytes:
+                    return await response.content.read()
+                elif not response_model:
+                    return await response.json()
+                return response_model.model_validate(await response.json(), from_attributes=True)
 
 
 class HttpxWebClient(BaseWebClient):
@@ -69,7 +72,11 @@ async def _request(self, request_info: RequestInfo) -> Any:
         async with httpx.AsyncClient(timeout=self.timeout) as client:
             response = await client.request(**request_params)
             response.raise_for_status()
-            data = response.json()
-            if response_model is not None:
-                return response_model.model_validate(data, from_attributes=True)
-            return data
+
+            if response_model is str:
+                return response.text
+            elif response_model is bytes:
+                return response.content
+            elif not response_model:
+                return response.json()
+            return response_model.model_validate(response.json(), from_attributes=True)

pydantic_client/decorators.py

@@ -36,11 +36,12 @@ def _process_request_params(
     # Get return type for response model
     return_type = sig.return_annotation
 
-    response_model = (
-        return_type
-        if isinstance(return_type, type) and issubclass(return_type, BaseModel)
-        else None
-    )
+    if isinstance(return_type, type) and issubclass(return_type, BaseModel):
+        response_model = return_type
+    elif return_type in [str, bytes]:
+        response_model = return_type
+    else:
+        response_model = None
 
     # Format path with parameters
     formatted_path = path.format(**params)

pydantic_client/sync_client.py

@@ -29,8 +29,11 @@ def _request(self, request_info: RequestInfo) -> Any:
 
         response = requests.request(**request_params, timeout=self.timeout)
         response.raise_for_status()
-
-        data = response.json()
-        if response_model is not None:
-            return response_model.model_validate(data, from_attributes=True)
-        return data
+        
+        if response_model is str:
+            return response.text
+        elif response_model is bytes:
+            return response.content
+        elif not response_model:
+            return response.json()
+        return response_model.model_validate(response.json(), from_attributes=True)

tests/conftest.py

@@ -28,8 +28,13 @@ async def user_by_id(request):
         "email": f"user{user_id}@example.com"
     })
 
+
 async def list_users(request):
-    return web.json_response({})
+    return web.json_response({"users": []})
+
+
+async def get_user_string(request):
+    return web.Response(text="abc")
 
 
 @pytest.fixture
@@ -48,6 +53,9 @@ async def mock_server(aiohttp_client) -> AsyncGenerator[
     app.router.add_post('/echo', echo_json)
     app.router.add_get('/users/{user_id}', user_by_id)
     app.router.add_get('/users', list_users)
+    app.router.add_post('/users/string', get_user_string)
+    app.router.add_post('/users/bytes', get_user_string)
+    app.router.add_post('/users/dict', list_users)
 
     client = await aiohttp_client(app)
     yield client

tests/test_async_client.py

@@ -17,6 +17,18 @@ async def get_user(self, user_id: str) -> User:
     @post("/users")
     async def create_user(self, name: str, email: str) -> User:
         ...
+    
+    @post("/users/string")
+    async def get_user_string(self, name: str) -> str:
+        ...
+    
+    @post("/users/bytes")
+    async def get_user_bytes(self, name: str) -> bytes:
+        ...
+    
+    @post("/users/dict")
+    async def get_user_dict(self, name: str) -> dict:
+        ...
 
 
 class TestHttpxClient(HttpxWebClient):
@@ -27,6 +39,18 @@ async def get_user(self, user_id: str) -> User:
     @post("/users")
     async def create_user(self, name: str, email: str) -> User:
         ...
+    
+    @post("/users/string")
+    async def get_user_string(self, name: str) -> str:
+        ...
+    
+    @post("/users/bytes")
+    async def get_user_bytes(self, name: str) -> bytes:
+        ...
+    
+    @post("/users/dict")
+    async def get_user_dict(self, name: str) -> dict:
+        ...
 
 
 @pytest.mark.asyncio
@@ -62,4 +86,58 @@ async def test_aiohttp_error_handling(mock_server, base_url):
 async def test_httpx_error_handling(mock_server, base_url):
     client = TestHttpxClient(base_url=f"{base_url}/nonexistent")
     with pytest.raises(BaseException):
-        await client.get_user("123")
+        await client.get_user("123")
+
+
+@pytest.mark.asyncio
+async def test_aiohttp_get_string_request(mock_server, base_url):
+    client = TestAiohttpClient(base_url=base_url)
+    response = await client.get_user_string("123")
+
+    assert isinstance(response, str)
+    assert response == "abc"
+
+
+@pytest.mark.asyncio
+async def test_aiohttp_get_bytes_request(mock_server, base_url):
+    client = TestAiohttpClient(base_url=base_url)
+    response = await client.get_user_bytes("123")
+    print(response)
+    assert isinstance(response, bytes)
+    assert response == "abc".encode()
+
+
+@pytest.mark.asyncio
+async def test_httpx_get_dict_request(mock_server, base_url):
+    client = TestAiohttpClient(base_url=base_url)
+    response = await client.get_user_dict("123")
+
+    assert isinstance(response, dict)
+    assert response == {"users": []}
+
+
+@pytest.mark.asyncio
+async def test_httpx_get_string_request(mock_server, base_url):
+    client = TestHttpxClient(base_url=base_url)
+    response = await client.get_user_string("123")
+
+    assert isinstance(response, str)
+    assert response == "abc"
+
+
+@pytest.mark.asyncio
+async def test_httpx_get_bytes_request(mock_server, base_url):
+    client = TestHttpxClient(base_url=base_url)
+    response = await client.get_user_bytes("123")
+    print(response)
+    assert isinstance(response, bytes)
+    assert response == "abc".encode()
+
+
+@pytest.mark.asyncio
+async def test_aiohttp_get_dict_request(mock_server, base_url):
+    client = TestHttpxClient(base_url=base_url)
+    response = await client.get_user_dict("123")
+
+    assert isinstance(response, dict)
+    assert response == {"users": []}

tests/test_sync_client.py

@@ -20,6 +20,18 @@ def get_user(self, user_id: str) -> User:
     def create_user(self, name: str, email: str) -> User:
         ...
 
+    @get("/users/string")
+    def get_user_string(self, name: str) -> str:
+        ...
+    
+    @get("/users/bytes")
+    def get_user_bytes(self, name: str) -> bytes:
+        ...
+    
+    @get("/users/dict")
+    def get_user_dict(self, name: str) -> dict:
+        ...
+
 
 def test_sync_get_request():
     with requests_mock.Mocker() as m:
@@ -66,4 +78,46 @@ def test_sync_error_handling():
 
         client = TestClient(base_url="http://example.com")
         with pytest.raises(requests.exceptions.HTTPError):
-            client.get_user("123")
+            client.get_user("123")
+
+
+def test_sync_get_string_request():
+    with requests_mock.Mocker() as m:
+        m.get(
+            'http://example.com/users/string',
+            text="ac"
+        )
+
+        client = TestClient(base_url="http://example.com")
+        response = client.get_user_string("123")
+
+        assert isinstance(response, str)
+        assert response == "ac"
+
+
+def test_sync_get_bytes_request():
+    with requests_mock.Mocker() as m:
+        m.get(
+            'http://example.com/users/bytes',
+            content="123".encode()
+        )
+
+        client = TestClient(base_url="http://example.com")
+        response = client.get_user_bytes("123")
+
+        assert isinstance(response, bytes)
+        assert response == b"123"
+
+
+def test_sync_get_dict_request():
+    with requests_mock.Mocker() as m:
+        m.get(
+            'http://example.com/users/dict',
+            json={"user": 123}
+        )
+
+        client = TestClient(base_url="http://example.com")
+        response = client.get_user_dict("123")
+
+        assert isinstance(response, dict)
+        assert response == {"user": 123}