feat(recommend): add client (#539)

Author: shortcuts

algoliasearch/helpers_async.py

@@ -34,7 +34,10 @@ def closure(*args, **kwargs):
 
         # We make sure we resolve the promise from the raw_responses
         if hasattr(result, "raw_responses"):
-            for (i, raw_response,) in enumerate(result.raw_responses):
+            for (
+                i,
+                raw_response,
+            ) in enumerate(result.raw_responses):
                 result.raw_responses[i] = yield from raw_response
 
         # We make sure we resolve the promise from the raw_response

algoliasearch/http/requester.py

@@ -37,7 +37,9 @@ def send(self, request):
 
         try:
             response = self._session.send(  # type: ignore
-                r, timeout=requests_timeout, proxies=request.proxies,
+                r,
+                timeout=requests_timeout,
+                proxies=request.proxies,
             )
         except Timeout as e:
             return Response(error_message=str(e), is_timed_out_error=True)

algoliasearch/recommend_client.py

@@ -0,0 +1,91 @@
+from typing import Optional, Union, List
+
+from algoliasearch.helpers import is_async_available
+from algoliasearch.http.request_options import RequestOptions
+from algoliasearch.http.verb import Verb
+from algoliasearch.configs import SearchConfig
+from algoliasearch.http.requester import Requester
+from algoliasearch.http.transporter import Transporter
+
+
+class RecommendClient(object):
+    @property
+    def app_id(self):
+        # type: () -> str
+
+        return self._config.app_id
+
+    def __init__(self, transporter, search_config):
+        # type: (Transporter, SearchConfig) -> None
+
+        self._transporter = transporter
+        self._config = search_config
+
+    @staticmethod
+    def create(app_id=None, api_key=None):
+        # type: (Optional[str], Optional[str]) -> RecommendClient
+
+        config = SearchConfig(app_id, api_key)
+
+        return RecommendClient.create_with_config(config)
+
+    @staticmethod
+    def create_with_config(config):
+        # type: (SearchConfig) -> RecommendClient
+
+        requester = Requester()
+        transporter = Transporter(requester, config)
+
+        client = RecommendClient(transporter, config)
+
+        if is_async_available():
+            from algoliasearch.recommend_client_async import RecommendClientAsync
+            from algoliasearch.http.transporter_async import TransporterAsync
+            from algoliasearch.http.requester_async import RequesterAsync
+
+            return RecommendClientAsync(
+                client, TransporterAsync(RequesterAsync(), config), config
+            )
+
+        return client
+
+    def get_recommendations(self, queries, request_options=None):
+        # type: (List[dict], Optional[Union[dict, RequestOptions]]) -> dict
+
+        for q in queries:
+            if "threshold" not in q or q["threshold"] is None:
+                q["threshold"] = 0
+
+        return self._transporter.read(
+            Verb.POST,
+            "1/indexes/*/recommendations",
+            {"requests": queries},
+            request_options,
+        )
+
+    def get_related_products(self, queries, request_options=None):
+        # type: (List[dict], Optional[Union[dict, RequestOptions]]) -> dict
+
+        for q in queries:
+            q["model"] = "related-products"
+
+        return self.get_recommendations(queries, request_options)
+
+    def get_frequently_bought_together(self, queries, request_options=None):
+        # type: (List[dict], Optional[Union[dict, RequestOptions]]) -> dict
+
+        for q in queries:
+            q.pop("fallbackParameters", None)
+            q["model"] = "bought-together"
+
+        return self.get_recommendations(queries, request_options)
+
+    def close(self):
+        # type: () -> None
+
+        return self._transporter.close()  # type: ignore
+
+    def _sync(self):
+        # type: () -> RecommendClient
+
+        return self

algoliasearch/recommend_client_async.py

@@ -0,0 +1,50 @@
+from algoliasearch.recommend_client import RecommendClient
+from typing import Optional, Type
+
+import types
+import asyncio
+
+from algoliasearch.configs import SearchConfig
+from algoliasearch.helpers_async import _create_async_methods_in
+from algoliasearch.http.transporter_async import TransporterAsync
+
+
+class RecommendClientAsync(RecommendClient):
+    def __init__(self, recommend_client, transporter, search_config):
+        # type: (RecommendClient, TransporterAsync, SearchConfig) -> None
+
+        self._recommend_client = recommend_client
+        self._transporter_async = transporter
+
+        super(RecommendClientAsync, self).__init__(
+            recommend_client._transporter, search_config
+        )
+
+        recommend_client = RecommendClient(transporter, search_config)
+        recommend_client.__setattr__("_sync", self._sync)
+        _create_async_methods_in(self, recommend_client)
+
+    @asyncio.coroutine
+    def __aenter__(self):
+        # type: () -> RecommendClientAsync # type: ignore
+
+        return self  # type: ignore
+
+    @asyncio.coroutine
+    def __aexit__(self, exc_type, exc, tb):  # type: ignore
+        # type: (Optional[Type[BaseException]], Optional[BaseException],Optional[types.TracebackType]) -> None # noqa: E501
+
+        yield from self.close_async()  # type: ignore
+
+    @asyncio.coroutine
+    def close_async(self):  # type: ignore
+        # type: () -> None
+
+        super().close()
+
+        yield from self._transporter_async.close()  # type: ignore
+
+    def _sync(self):
+        # type: () -> RecommendClient
+
+        return self._recommend_client

algoliasearch/recommendation_client.py

@@ -15,7 +15,12 @@ def __init__(self, transporter, config):
 
         warnings.warn(
             "`%s.%s` is deprecated, use `%s.%s` instead."
-            % ("RecommendationClient", "init", "PersonalizationClient", "init",),
+            % (
+                "RecommendationClient",
+                "init",
+                "PersonalizationClient",
+                "init",
+            ),
             DeprecationWarning,
         )
 
@@ -28,7 +33,12 @@ def create(app_id=None, api_key=None, region=None):
 
         warnings.warn(
             "`%s.%s` is deprecated, use `%s.%s` instead."
-            % ("RecommendationClient", "create", "PersonalizationClient", "create",),
+            % (
+                "RecommendationClient",
+                "create",
+                "PersonalizationClient",
+                "create",
+            ),
             DeprecationWarning,
         )
 
@@ -115,7 +125,12 @@ def close(self):
 
         warnings.warn(
             "`%s.%s` is deprecated, use `%s.%s` instead."
-            % ("RecommendationClient", "close", "PersonalizationClient", "close",),
+            % (
+                "RecommendationClient",
+                "close",
+                "PersonalizationClient",
+                "close",
+            ),
             DeprecationWarning,
         )
 

algoliasearch/search_index_async.py

@@ -137,7 +137,9 @@ def find_object_async(self, callback, request_options=None):  # type: ignore # n
             page += 1
 
     def replace_all_objects_async(  # type: ignore
-        self, objects, request_options=None,
+        self,
+        objects,
+        request_options=None,
     ):
         # type: (Union[List[dict], Iterator[dict]], Optional[Union[dict, RequestOptions]]) -> MultipleResponse # noqa: E501