chore(python): proper type hinting

Author: Fluf22

clients/algoliasearch-client-python/algoliasearch/http/api_response.py

@@ -21,7 +21,7 @@ class ApiResponse(Generic[T]):
     def __init__(
         self,
         verb: Verb,
-        data: T = None,
+        data: Optional[T] = None,
         error_message: str = "",
         headers: Optional[Dict[str, str]] = None,
         host: str = "",

clients/algoliasearch-client-python/algoliasearch/http/base_config.py

@@ -5,20 +5,6 @@
 
 
 class BaseConfig:
-    app_id: Optional[str]
-    api_key: Optional[str]
-
-    read_timeout: int
-    write_timeout: int
-    connect_timeout: int
-
-    wait_task_time_before_retry: Optional[int]
-
-    headers: Dict[str, str]
-    proxies: Dict[str, str]
-
-    hosts: HostsCollection
-
     def __init__(self, app_id: Optional[str] = None, api_key: Optional[str] = None):
         app_id = environ.get("ALGOLIA_APP_ID") if app_id is None else app_id
 
@@ -36,10 +22,10 @@ def __init__(self, app_id: Optional[str] = None, api_key: Optional[str] = None):
         self.write_timeout = 30000
         self.connect_timeout = 2000
 
-        self.wait_task_time_before_retry = None
-        self.headers = None
-        self.proxies = None
-        self.hosts = None
+        self.wait_task_time_before_retry: Optional[int] = None
+        self.headers: Optional[Dict[str, str]] = None
+        self.proxies: Optional[Dict[str, str]] = None
+        self.hosts: Optional[HostsCollection] = None
 
     def set_client_api_key(self, api_key: str) -> None:
         """Sets a new API key to authenticate requests."""

clients/algoliasearch-client-python/algoliasearch/http/base_transporter.py

@@ -1,20 +1,21 @@
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 from algoliasearch.http.base_config import BaseConfig
-from algoliasearch.http.hosts import Host
+from algoliasearch.http.hosts import HostsCollection
 from algoliasearch.http.request_options import RequestOptions
 from algoliasearch.http.retry import RetryStrategy
 
 
 class BaseTransporter:
-    _config: BaseConfig
-    _retry_strategy: RetryStrategy
-    _hosts: List[Host]
-
     def __init__(self, config: BaseConfig) -> None:
         self._config = config
         self._retry_strategy = RetryStrategy()
-        self._hosts = []
+        self._hosts: HostsCollection = []
+        self._timeout = 5000
+
+    @property
+    def config(self) -> BaseConfig:
+        return self._config
 
     def prepare(
         self,

clients/algoliasearch-client-python/algoliasearch/http/hosts.py

@@ -18,8 +18,9 @@ def __init__(
         self.port = port
         self.priority = cast(int, priority)
         self.accept = (CallType.WRITE | CallType.READ) if accept is None else accept
-
-        self.reset()
+        self.last_use = 0.0
+        self.retry_count = 0
+        self.up = True
 
     def reset(self) -> None:
         self.last_use = 0.0

clients/algoliasearch-client-python/algoliasearch/http/request_options.py

@@ -1,6 +1,6 @@
 from copy import deepcopy
 from sys import version_info
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, Optional, Union
 from urllib.parse import quote
 
 from algoliasearch.http.base_config import BaseConfig
@@ -13,20 +13,22 @@
 
 
 class RequestOptions:
-    _config: BaseConfig
-    headers: Dict[str, str]
-    query_parameters: Dict[str, Any]
-    timeouts: Dict[str, int]
-    data: Dict[str, Any]
-
     def __init__(
         self,
         config: BaseConfig,
-        headers: Dict[str, str] = {},
-        query_parameters: Dict[str, Any] = {},
-        timeouts: Dict[str, int] = {},
-        data: Dict[str, Any] = {},
+        headers: Dict[str, str] = None,
+        query_parameters: Dict[str, Any] = None,
+        timeouts: Dict[str, int] = None,
+        data: Dict[str, Any] = None,
     ) -> None:
+        if headers is None:
+            headers = {}
+        if query_parameters is None:
+            query_parameters = {}
+        if timeouts is None:
+            timeouts = {}
+        if data is None:
+            data = {}
         self._config = config
         self.headers = headers
         self.query_parameters = {
@@ -48,28 +50,39 @@ def from_dict(self, data: Dict[str, Dict[str, Any]]) -> Self:
         return RequestOptions(
             config=self._config,
             headers=data.get("headers", {}),
-            query_parameters=data.get("query_parameters", {}),
+            query_parameters={
+                quote(k): quote(v)
+                for k, v in QueryParametersSerializer(
+                    data.get("query_parameters", {})
+                ).query_parameters.items()
+            },
             timeouts=data.get("timeouts", {}),
             data=data.get("data", {}),
         )
 
     def merge(
         self,
-        query_parameters: List[Tuple[str, str]] = [],
-        headers: Dict[str, Optional[str]] = {},
-        _: Dict[str, int] = {},
+        query_parameters: Dict[str, Any] = None,
+        headers: Dict[str, str] = None,
+        timeouts: Dict[str, int] = None,
         data: Optional[str] = None,
         user_request_options: Optional[Union[Self, Dict[str, Any]]] = None,
     ) -> Self:
         """
         Merges the default config values with the user given request options if it exists.
         """
 
+        if query_parameters is None:
+            query_parameters = {}
+        if headers is None:
+            headers = {}
+        if timeouts is None:
+            timeouts = {}
         headers.update(self._config.headers)
 
         request_options = {
             "headers": headers,
-            "query_parameters": {k: v for k, v in query_parameters},
+            "query_parameters": query_parameters,
             "timeouts": {
                 "read": self._config.read_timeout,
                 "write": self._config.write_timeout,

clients/algoliasearch-client-python/algoliasearch/http/retry.py

@@ -14,7 +14,7 @@ class RetryOutcome:
 class RetryStrategy:
     def valid_hosts(self, hosts: List[Host]) -> List[Host]:
         for host in hosts:
-            if not host.up and self._now() - host.last_use > Host.TTL:
+            if not host.up and time.time() - host.last_use > Host.TTL:
                 host.up = True
 
         return [host for host in hosts if host.up]

clients/algoliasearch-client-python/algoliasearch/http/serializer.py

@@ -10,7 +10,16 @@ class QueryParametersSerializer:
     Parses the given 'query_parameters' values of each keys into their string value.
     """
 
-    query_parameters: Dict[str, Any] = {}
+    def __init__(self, query_parameters: Optional[Dict[str, Any]]) -> None:
+        self.query_parameters: Dict[str, Any] = {}
+        if query_parameters is None:
+            return
+        for key, value in query_parameters.items():
+            if isinstance(value, dict):
+                for dkey, dvalue in value.items():
+                    self.query_parameters[dkey] = self.parse(dvalue)
+            else:
+                self.query_parameters[key] = self.parse(value)
 
     def parse(self, value) -> Any:
         if isinstance(value, list):
@@ -27,19 +36,8 @@ def encoded(self) -> str:
             dict(sorted(self.query_parameters.items(), key=lambda val: val[0]))
         ).replace("+", "%20")
 
-    def __init__(self, query_parameters: Optional[Dict[str, Any]]) -> None:
-        self.query_parameters = {}
-        if query_parameters is None:
-            return
-        for key, value in query_parameters.items():
-            if isinstance(value, dict):
-                for dkey, dvalue in value.items():
-                    self.query_parameters[dkey] = self.parse(dvalue)
-            else:
-                self.query_parameters[key] = self.parse(value)
-
 
-def bodySerializer(obj: Any) -> Any:
+def body_serializer(obj: Any) -> Any:
     """Builds a JSON POST object.
 
     If obj is None, return None.
@@ -57,14 +55,14 @@ def bodySerializer(obj: Any) -> Any:
     elif isinstance(obj, PRIMITIVE_TYPES):
         return obj
     elif isinstance(obj, list):
-        return [bodySerializer(sub_obj) for sub_obj in obj]
+        return [body_serializer(sub_obj) for sub_obj in obj]
     elif isinstance(obj, tuple):
-        return tuple(bodySerializer(sub_obj) for sub_obj in obj)
+        return tuple(body_serializer(sub_obj) for sub_obj in obj)
     elif isinstance(obj, dict):
         obj_dict = obj
     else:
         obj_dict = obj.to_dict()
         if obj_dict is None:
             return None
 
-    return {key: bodySerializer(val) for key, val in obj_dict.items()}
+    return {key: body_serializer(val) for key, val in obj_dict.items()}

clients/algoliasearch-client-python/algoliasearch/http/transporter.py

@@ -1,5 +1,6 @@
 from asyncio import TimeoutError
 from json import loads
+from typing import Optional
 
 from aiohttp import ClientSession, TCPConnector
 from async_timeout import timeout
@@ -11,19 +12,18 @@
     AlgoliaUnreachableHostException,
     RequestException,
 )
+from algoliasearch.http.hosts import HostsCollection
 from algoliasearch.http.request_options import RequestOptions
 from algoliasearch.http.retry import RetryOutcome, RetryStrategy
 from algoliasearch.http.verb import Verb
 
 
 class Transporter(BaseTransporter):
-    _session: ClientSession
-
     def __init__(self, config: BaseConfig) -> None:
-        self._session = None
+        self._session: Optional[ClientSession] = None
         self._config = config
         self._retry_strategy = RetryStrategy()
-        self._hosts = []
+        self._hosts: HostsCollection = []
 
     async def close(self) -> None:
         if self._session is not None:
@@ -103,6 +103,7 @@ async def request(
 
 class EchoTransporter(Transporter):
     def __init__(self, config: BaseConfig) -> None:
+        super().__init__(config)
         self._config = config
         self._retry_strategy = RetryStrategy()
 

clients/algoliasearch-client-python/algoliasearch/http/transporter_sync.py

@@ -3,8 +3,10 @@
 
 from requests import Request, Session, Timeout
 
+from algoliasearch.http.hosts import HostsCollection
+
 if version_info >= (3, 11):
-    from typing import Self
+    from typing import Optional, Self
 else:
     from typing_extensions import Self
 
@@ -24,13 +26,11 @@
 
 
 class TransporterSync(BaseTransporter):
-    _session: Session
-
     def __init__(self, config: BaseConfig) -> None:
-        self._session = None
+        self._session: Optional[Session] = None
         self._config = config
         self._retry_strategy = RetryStrategy()
-        self._hosts = []
+        self._hosts: HostsCollection = []
 
     def __enter__(self) -> Self:
         return self
@@ -86,7 +86,7 @@ def request(
                     url=url,
                     host=host.url,
                     status_code=resp.status_code,
-                    headers=resp.headers,  # type: ignore -- insensitive dict is still a dict
+                    headers=resp.headers,  # type: ignore # insensitive dict is still a dict
                     data=resp.text,
                     raw_data=resp.text,
                     error_message=str(resp.reason),
@@ -117,6 +117,7 @@ def request(
 
 class EchoTransporterSync(TransporterSync):
     def __init__(self, config: BaseConfig) -> None:
+        super().__init__(config)
         self._config = config
         self._retry_strategy = RetryStrategy()
 

clients/algoliasearch-client-python/algoliasearch/http/user_agent.py

@@ -11,14 +11,14 @@
 
 
 class UserAgent:
+    def __init__(self) -> None:
+        self.value = "Algolia for Python ({}); Python ({})".format(
+            __version__, str(python_version())
+        )
+
     def get(self) -> str:
         return self.value
 
     def add(self, segment: str, version: Optional[str] = __version__) -> Self:
         self.value += "; {} ({})".format(segment, version)
         return self
-
-    def __init__(self) -> None:
-        self.value = "Algolia for Python ({}); Python ({})".format(
-            __version__, str(python_version())
-        )