Fix tests

Author: heyitsaamir

.github/workflows/ci.yml

@@ -82,3 +82,8 @@ jobs:
             --disable-error-code=import-untyped \
             --disable-error-code=no-untyped-call \
             packages/
+
+      - name: Run Tests
+        run: |
+          source .venv/bin/activate
+          pytest packages

mypy.ini

@@ -1,13 +1,5 @@
 [mypy]
 python_version = 3.12
-strict = True
+strict = False
 warn_unused_configs = True
-
-[mypy-botbuilder.*]
-ignore_missing_imports = True
-
-[mypy-botframework.*]
-ignore_missing_imports = True
-
-[mypy-sqlite_vec.*]
-ignore_missing_imports = True
+exclude = tests/

packages/common/src/common/http/client.py

@@ -1,12 +1,17 @@
+import inspect
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 import httpx
+from httpx._models import Request, Response
+from httpx._types import QueryParamTypes, RequestContent, RequestData, RequestFiles
 
 from common.http.clientToken import Token, resolve_token
 from common.http.interceptor import Interceptor, InterceptorRequestContext, InterceptorResponseContext
 from common.logging import ConsoleLogger, Logger
 
+console_logger = ConsoleLogger()
+
 
 @dataclass(frozen=True)
 class ClientOptions:
@@ -23,9 +28,9 @@ class ClientOptions:
     """
 
     base_url: Optional[str] = None
-    headers: Optional[Dict[str, str]] = field(default_factory=dict)
+    headers: Dict[str, str] = field(default_factory=dict)
     timeout: Optional[float] = None
-    logger: Logger = field(default_factory=ConsoleLogger)
+    logger: Logger = field(default_factory=lambda: console_logger.create_logger("http-client"))
     token: Optional[Token] = None
     interceptors: Optional[List[Interceptor]] = field(default_factory=list)
 
@@ -53,7 +58,7 @@ def __init__(self, options: ClientOptions):
         self._interceptors = list(options.interceptors or [])
 
         self.http = httpx.AsyncClient(
-            base_url=options.base_url,
+            base_url=httpx.URL(options.base_url) if options.base_url else "",
             headers=options.headers,
             timeout=options.timeout,
         )
@@ -77,31 +82,42 @@ async def _prepare_headers(self, headers: Optional[Dict[str, str]], token: Optio
         return req_headers
 
     async def get(
-        self, url: str, *, headers: Optional[Dict[str, str]] = None, token: Optional[Token] = None, **kwargs
+        self,
+        url: str,
+        *,
+        headers: Optional[Dict[str, str]] = None,
+        token: Optional[Token] = None,
+        params: Optional[QueryParamTypes] = None,
+        **kwargs: Any,
     ) -> httpx.Response:
         """
         Send a GET request.
 
         Args:
             url: The URL path or full URL.
             headers: Optional per-request headers.
+            params: Optional query parameters.
             token: Optional per-request token (overrides default).
             **kwargs: Additional httpx.AsyncClient.get arguments.
 
         Returns:
             httpx.Response
         """
         req_headers = await self._prepare_headers(headers, token)
-        return await self.http.get(url, headers=req_headers, **kwargs)
+        return await self.http.get(url, headers=req_headers, params=params, **kwargs)
 
     async def post(
         self,
         url: str,
-        data: Any = None,
         *,
+        content: Optional[RequestContent] = None,
+        data: Optional[RequestData] = None,
+        files: Optional[RequestFiles] = None,
+        json: Optional[Any] = None,
+        params: Optional[QueryParamTypes] = None,
         headers: Optional[Dict[str, str]] = None,
         token: Optional[Token] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> httpx.Response:
         """
         Send a POST request.
@@ -110,23 +126,40 @@ async def post(
             url: The URL path or full URL.
             data: The request body.
             headers: Optional per-request headers.
+            params: Optional query parameters.
+            content: The request body.
+            files: The request files.
+            json: The request JSON body.
             token: Optional per-request token (overrides default).
             **kwargs: Additional httpx.AsyncClient.post arguments.
 
         Returns:
             httpx.Response
         """
         req_headers = await self._prepare_headers(headers, token)
-        return await self.http.post(url, data=data, headers=req_headers, **kwargs)
+        return await self.http.post(
+            url,
+            data=data,
+            files=files,
+            json=json,
+            content=content,
+            params=params,
+            headers=req_headers,
+            **kwargs,
+        )
 
     async def put(
         self,
         url: str,
-        data: Any = None,
         *,
+        content: Optional[RequestContent] = None,
+        data: Optional[RequestData] = None,
+        files: Optional[RequestFiles] = None,
+        json: Optional[Any] = None,
+        params: Optional[QueryParamTypes] = None,
         headers: Optional[Dict[str, str]] = None,
         token: Optional[Token] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> httpx.Response:
         """
         Send a PUT request.
@@ -135,23 +168,40 @@ async def put(
             url: The URL path or full URL.
             data: The request body.
             headers: Optional per-request headers.
+            params: Optional query parameters.
+            content: The request body.
+            files: The request files.
+            json: The request JSON body.
             token: Optional per-request token (overrides default).
             **kwargs: Additional httpx.AsyncClient.put arguments.
 
         Returns:
             httpx.Response
         """
         req_headers = await self._prepare_headers(headers, token)
-        return await self.http.put(url, data=data, headers=req_headers, **kwargs)
+        return await self.http.put(
+            url,
+            data=data,
+            files=files,
+            json=json,
+            content=content,
+            params=params,
+            headers=req_headers,
+            **kwargs,
+        )
 
     async def patch(
         self,
         url: str,
-        data: Any = None,
         *,
+        content: Optional[RequestContent] = None,
+        data: Optional[RequestData] = None,
+        files: Optional[RequestFiles] = None,
+        json: Optional[Any] = None,
+        params: Optional[QueryParamTypes] = None,
         headers: Optional[Dict[str, str]] = None,
         token: Optional[Token] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> httpx.Response:
         """
         Send a PATCH request.
@@ -160,41 +210,66 @@ async def patch(
             url: The URL path or full URL.
             data: The request body.
             headers: Optional per-request headers.
+            params: Optional query parameters.
+            content: The request body.
+            files: The request files.
+            json: The request JSON body.
             token: Optional per-request token (overrides default).
             **kwargs: Additional httpx.AsyncClient.patch arguments.
 
         Returns:
             httpx.Response
         """
         req_headers = await self._prepare_headers(headers, token)
-        return await self.http.patch(url, data=data, headers=req_headers, **kwargs)
+        return await self.http.patch(
+            url,
+            data=data,
+            files=files,
+            json=json,
+            content=content,
+            params=params,
+            headers=req_headers,
+            **kwargs,
+        )
 
     async def delete(
-        self, url: str, *, headers: Optional[Dict[str, str]] = None, token: Optional[Token] = None, **kwargs
+        self,
+        url: str,
+        *,
+        headers: Optional[Dict[str, str]] = None,
+        token: Optional[Token] = None,
+        params: Optional[QueryParamTypes] = None,
+        **kwargs: Any,
     ) -> httpx.Response:
         """
         Send a DELETE request.
 
         Args:
             url: The URL path or full URL.
             headers: Optional per-request headers.
+            params: Optional query parameters.
             token: Optional per-request token (overrides default).
             **kwargs: Additional httpx.AsyncClient.delete arguments.
 
         Returns:
             httpx.Response
         """
         req_headers = await self._prepare_headers(headers, token)
-        return await self.http.delete(url, headers=req_headers, **kwargs)
+        return await self.http.delete(url, headers=req_headers, params=params, **kwargs)
 
     async def request(
         self,
         method: str,
         url: str,
         *,
+        params: Optional[QueryParamTypes] = None,
         headers: Optional[Dict[str, str]] = None,
         token: Optional[Token] = None,
-        **kwargs,
+        content: Optional[RequestContent] = None,
+        data: Optional[RequestData] = None,
+        files: Optional[RequestFiles] = None,
+        json: Optional[Any] = None,
+        **kwargs: Any,
     ) -> httpx.Response:
         """
         Send a custom HTTP request.
@@ -203,14 +278,29 @@ async def request(
             method: HTTP method (GET, POST, etc).
             url: The URL path or full URL.
             headers: Optional per-request headers.
+            params: Optional query parameters.
+            content: The request body.
+            data: The request body.
+            files: The request files.
+            json: The request JSON body.
             token: Optional per-request token (overrides default).
             **kwargs: Additional httpx.AsyncClient.request arguments.
 
         Returns:
             httpx.Response
         """
         req_headers = await self._prepare_headers(headers, token)
-        return await self.http.request(method, url, headers=req_headers, **kwargs)
+        return await self.http.request(
+            method,
+            url,
+            headers=req_headers,
+            params=params,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            **kwargs,
+        )
 
     async def _resolve_token(self, token: Optional[Token]) -> Optional[str]:
         """
@@ -241,55 +331,55 @@ def _update_event_hooks(self) -> None:
         """
         Internal: Update the httpx.AsyncClient event_hooks to match current interceptors.
         """
-        event_hooks_dict = {}
+        event_hooks_dict: Dict[str, List[Callable[[Any], Any]]] = {}
         for hook in self._interceptors:
             if hasattr(hook, "request"):
 
-                def make_request_wrapper(h):
-                    async def wrapper(request):
+                def _make_request_wrapper(h: Interceptor):
+                    async def wrapper(request: Request):
                         ctx = InterceptorRequestContext(request, self.logger)
                         result = h.request(ctx)
-                        if hasattr(result, "__await__"):
+                        if inspect.isawaitable(result):
                             return await result
                         return result
 
                     return wrapper
 
-                event_hooks_dict.setdefault("request", []).append(make_request_wrapper(hook))
+                event_hooks_dict.setdefault("request", []).append(_make_request_wrapper(hook))
             if hasattr(hook, "response"):
 
-                def make_response_wrapper(h):
-                    async def wrapper(response):
+                def _make_response_wrapper(h: Interceptor):
+                    async def wrapper(response: Response):
                         ctx = InterceptorResponseContext(response, self.logger)
                         result = h.response(ctx)
-                        if hasattr(result, "__await__"):
+                        if inspect.isawaitable(result):
                             return await result
                         return result
 
                     return wrapper
 
-                event_hooks_dict.setdefault("response", []).append(make_response_wrapper(hook))
+                event_hooks_dict.setdefault("response", []).append(_make_response_wrapper(hook))
         self.http.event_hooks = event_hooks_dict
 
-    def clone(self, **overrides) -> "Client":
+    def clone(self, overrides: Optional[ClientOptions] = None) -> "Client":
         """
         Create a new Client instance with merged configuration.
 
         Args:
-            **overrides: Partial ClientOptions fields to override.
+            overrides: Optional ClientOptions object to override fields.
 
         Returns:
             A new Client instance with merged options and a cloned interceptor list.
         """
-        # Merge options, shallow copy interceptors array
+        overrides = overrides or ClientOptions()
         merged_options = ClientOptions(
-            base_url=overrides.get("base_url", self.options.base_url),
-            headers={**self.options.headers, **overrides.get("headers", {})}
-            if overrides.get("headers")
-            else dict(self.options.headers),
-            timeout=overrides.get("timeout", self.options.timeout),
-            logger=overrides.get("logger", self.options.logger),
-            token=overrides.get("token", self.options.token),
-            interceptors=list(overrides.get("interceptors", self._interceptors)),
+            base_url=overrides.base_url if overrides.base_url is not None else self.options.base_url,
+            headers={**self.options.headers, **(overrides.headers or {})},
+            timeout=overrides.timeout if overrides.timeout is not None else self.options.timeout,
+            logger=overrides.logger if overrides.logger is not None else self.options.logger,
+            token=overrides.token if overrides.token is not None else self.options.token,
+            interceptors=list(overrides.interceptors)
+            if overrides.interceptors is not None
+            else list(self._interceptors),
         )
         return Client(merged_options)