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())
-        )

templates/python/api.mustache

@@ -41,7 +41,7 @@ class {{classname}}{{#isSyncClient}}Sync{{/isSyncClient}}:
 
     def __init__(self, app_id: Optional[str] = None, api_key: Optional[str] = None, {{#hasRegionalHost}}region: {{#fallbackToAliasHost}}Optional[str]{{/fallbackToAliasHost}}{{^fallbackToAliasHost}}str{{/fallbackToAliasHost}} = None, {{/hasRegionalHost}}transporter: Optional[Transporter{{#isSyncClient}}Sync{{/isSyncClient}}] = None, config: Optional[{{#lambda.pascalcase}}{{client}}Config{{/lambda.pascalcase}}] = None) -> None:
         if transporter is not None and config is None:
-            config = transporter._config
+            config = transporter.config
 
         if config is None:
             config = {{#lambda.pascalcase}}{{client}}Config{{/lambda.pascalcase}}(app_id, api_key{{#hasRegionalHost}}, region{{/hasRegionalHost}})
@@ -99,7 +99,7 @@ class {{classname}}{{#isSyncClient}}Sync{{/isSyncClient}}:
 
     {{^isSyncClient}}async {{/isSyncClient}}def set_client_api_key(self, api_key: str) -> None:
         """Sets a new API key to authenticate requests."""
-        self._transporter._config.set_client_api_key(api_key)
+        self._transporter.config.set_client_api_key(api_key)
 
     {{#isSearchClient}}
 {{> search_helpers}}
@@ -138,7 +138,7 @@ class {{classname}}{{#isSyncClient}}Sync{{/isSyncClient}}:
         {{/allParams}}
 
         {{#queryParams.0}}
-        _query_parameters: List[Tuple[str, str]] = []
+        _query_parameters: Dict[str, Any] = {}
         {{/queryParams.0}}
         {{#headerParams.0}}
         _headers: Dict[str, Optional[str]] = {}
@@ -148,11 +148,11 @@ class {{classname}}{{#isSyncClient}}Sync{{/isSyncClient}}:
         {{#queryParams}}
         if {{paramName}} is not None:
         {{^x-is-custom-request}}
-            _query_parameters.append(('{{baseName}}', {{paramName}}))
+            _query_parameters["{{baseName}}"] = {{paramName}}
         {{/x-is-custom-request}}
         {{#x-is-custom-request}}
             for _qpkey, _qpvalue in {{paramName}}.items():
-                _query_parameters.append((_qpkey, _qpvalue))
+                _query_parameters[_qpkey] = _qpvalue
         {{/x-is-custom-request}}
         {{/queryParams}}
         {{/vendorExtensions}}
@@ -174,7 +174,7 @@ class {{classname}}{{#isSyncClient}}Sync{{/isSyncClient}}:
             request_options=self._request_options.merge(
                 {{#queryParams.0}}query_parameters=_query_parameters,{{/queryParams.0}}
                 {{#headerParams.0}}headers=_headers,{{/headerParams.0}}
-                {{#bodyParam}}data=dumps(bodySerializer(_data)),{{/bodyParam}}
+                {{#bodyParam}}data=dumps(body_serializer(_data)),{{/bodyParam}}
                 user_request_options=request_options,
             ),
             {{#vendorExtensions}}

templates/python/config.mustache

@@ -40,7 +40,7 @@ class {{#lambda.pascalcase}}{{client}}{{/lambda.pascalcase}}Config(BaseConfig):
         if {{^fallbackToAliasHost}}not region or {{/fallbackToAliasHost}}(region is not None and region not in _regions):
             raise ValueError(f"`region` {{^fallbackToAliasHost}}is required and {{/fallbackToAliasHost}}must be one of the following: {', '.join(_regions)}")
 
-        self.hosts = HostsCollection([Host({{#fallbackToAliasHost}}"{{{hostWithFallback}}}" if region is None else {{/fallbackToAliasHost}} "{{{regionalHost}}}".replace("{region}", region))])
+        self.hosts = HostsCollection([Host({{#fallbackToAliasHost}}"{{{hostWithFallback}}}" if region is None else {{/fallbackToAliasHost}} "{{{regionalHost}}}".replace("{region}", region or ""))])
         {{/hasRegionalHost}}
 
         {{^hasRegionalHost}}