athena-intelligence 0.1.83__tar.gz → 0.1.84__tar.gz

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/PKG-INFO

@@ -1,13 +1,23 @@
 Metadata-Version: 2.1
 Name: athena-intelligence
-Version: 0.1.83
-Summary: 
+Version: 0.1.84
+Summary: Athena Intelligence Python Library
 Requires-Python: >=3.8,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
 Requires-Dist: httpx (>=0.21.2)
 Requires-Dist: pydantic (>=1.9.2)
 Requires-Dist: python-magic (==0.4.27)

athena_intelligence-0.1.84/pyproject.toml

@@ -0,0 +1,60 @@
+[tool.poetry]
+name = "athena-intelligence"
+version = "0.1.84"
+description = "Athena Intelligence Python Library"
+readme = "README.md"
+authors = []
+keywords = []
+
+classifiers = [
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Operating System :: POSIX",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed"
+]
+packages = [
+    { include = "athena", from = "src"}
+]
+
+[project.urls]
+Documentation = 'https://docs.athenaintelligence.ai/'
+Homepage = 'https://www.athenaintelligence.ai/'
+Repository = 'https://github.com/Athena-Intel/athena-python'
+
+[tool.poetry.dependencies]
+python = "^3.8"
+httpx = ">=0.21.2"
+pydantic = ">= 1.9.2"
+python-magic = "0.4.27"
+typing_extensions = ">= 4.0.0"
+
+[tool.poetry.dev-dependencies]
+mypy = "1.9.0"
+pytest = "^7.4.0"
+pytest-asyncio = "^0.23.5"
+python-dateutil = "^2.9.0"
+pandas = ">= 1.5.3"
+pandas-stubs = ">= 1.5.3"
+
+[tool.pytest.ini_options]
+testpaths = [ "tests" ]
+asyncio_mode = "auto"
+
+[tool.mypy]
+plugins = ["pydantic.mypy"]
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/chain/client.py

@@ -8,6 +8,7 @@ from ..core.api_error import ApiError
 from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.jsonable_encoder import jsonable_encoder
 from ..core.pydantic_utilities import pydantic_v1
+from ..core.query_encoder import encode_query
 from ..core.remove_none_from_dict import remove_none_from_dict
 from ..core.request_options import RequestOptions
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
@@ -69,8 +70,10 @@ class ChainClient:
         _response = self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/structured-parse"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder({"text_input": text_input, "custom_type_dict": custom_type_dict, "model": model})
             if request_options is None or request_options.get("additional_body_parameters") is None
@@ -159,8 +162,10 @@ class ChainClient:
         _response = self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/tools/map-reduce"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder(
                 {
@@ -259,8 +264,10 @@ class AsyncChainClient:
         _response = await self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/structured-parse"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder({"text_input": text_input, "custom_type_dict": custom_type_dict, "model": model})
             if request_options is None or request_options.get("additional_body_parameters") is None
@@ -349,8 +356,10 @@ class AsyncChainClient:
         _response = await self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/tools/map-reduce"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder(
                 {

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/client.py

@@ -1,13 +1,65 @@
-# This file was auto-generated by Fern from our API Definition.
-
+import io
 import typing
+import warnings
 
 import httpx
+from typing_extensions import TypeVar, ParamSpec
 
 from .base_client import BaseAthena, AsyncBaseAthena
 from .environment import AthenaEnvironment
-from .polling_message_client import \
-        MessagePollingClient, AsyncMessagePollingClient
+from .polling_message_client import MessagePollingClient, AsyncMessagePollingClient
+from .tools.client import AsyncToolsClient, ToolsClient
+from .types.data_frame_request_out import DataFrameRequestOut
+
+if typing.TYPE_CHECKING:
+    import pandas as pd
+
+
+P = ParamSpec("P")
+T = TypeVar("T")
+U = TypeVar('U')
+
+
+def _inherit_signature(f: typing.Callable[P, T]) -> typing.Callable[..., typing.Callable[P, U]]:
+    return lambda x: x
+
+
+class WrappedToolsClient(ToolsClient):
+
+    def get_file(self, document_id: str) -> io.BytesIO:
+        file_bytes = b''.join(self.raw_data(document_id=document_id))
+        bytes_io = io.BytesIO(file_bytes)
+        return bytes_io
+
+    @_inherit_signature(ToolsClient.data_frame)
+    def data_frame(self, *, document_id: str, **kwargs) -> 'pd.DataFrame':
+        _check_pandas_installed()
+        model = super().data_frame(document_id=document_id, **kwargs)
+        return _read_json_frame(model)
+
+    def read_data_frame(self, document_id: str, *args, **kwargs) -> 'pd.DataFrame':
+        _check_pandas_installed()
+        file_bytes = self.get_file(document_id)
+        return _to_pandas_df(file_bytes, *args, **kwargs)
+
+
+class WrappedAsyncToolsClient(AsyncToolsClient):
+
+    async def get_file(self, document_id: str) -> io.BytesIO:
+        file_bytes = b''.join([gen async for gen in self.raw_data(document_id=document_id)])
+        bytes_io = io.BytesIO(file_bytes)
+        return bytes_io
+
+    @_inherit_signature(ToolsClient.data_frame)
+    async def data_frame(self, *, document_id: str, **kwargs) -> 'pd.DataFrame':
+        _check_pandas_installed()
+        model = await super().data_frame(document_id=document_id, **kwargs)
+        return _read_json_frame(model)
+
+    async def read_data_frame(self, document_id: str, *args, **kwargs) -> 'pd.DataFrame':
+        _check_pandas_installed()
+        file_bytes = await self.get_file(document_id)
+        return _to_pandas_df(file_bytes, *args, **kwargs)
 
 
 class Athena(BaseAthena):
@@ -52,6 +104,7 @@ class Athena(BaseAthena):
         )
         self.message = MessagePollingClient(
             client_wrapper=self._client_wrapper)
+        self.tools = WrappedToolsClient(client_wrapper=self._client_wrapper)
 
 
 class AsyncAthena(AsyncBaseAthena):
@@ -96,4 +149,38 @@ class AsyncAthena(AsyncBaseAthena):
         )
         self.message = AsyncMessagePollingClient(
             client_wrapper=self._client_wrapper)
+        self.tools = WrappedAsyncToolsClient(client_wrapper=self._client_wrapper)
+
+
+def _read_json_frame(model: DataFrameRequestOut) -> 'pd.DataFrame':
+    import pandas as pd
+
+    string_io = io.StringIO(model.json())
+
+    with warnings.catch_warnings():
+        # Filter warnings due to https://github.com/pandas-dev/pandas/issues/59511
+        warnings.simplefilter(action='ignore', category=FutureWarning)
+        return pd.read_json(string_io, orient='split')
+
+
+def _check_pandas_installed():
+    import pandas
+    assert pandas
+
+
+def _to_pandas_df(bytes_io: io.BytesIO, *args, **kwargs):
+    import pandas as pd
+    import magic
+
+    # ideally this would be read from response header, but fern SDK for Python hides this info from us
+    media_type = magic.from_buffer(bytes_io.read(2048), mime=True)
+    bytes_io.seek(0)
 
+    if media_type == 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
+        return pd.read_excel(bytes_io, *args, engine='openpyxl', **kwargs)
+    elif media_type == 'application/vnd.ms-excel':
+        return pd.read_excel(bytes_io, *args, **kwargs)
+    elif media_type == 'text/csv':
+        return pd.read_csv(bytes_io, *args, **kwargs)
+    else:
+        raise Exception("Unknown media type")

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/core/__init__.py

@@ -6,7 +6,8 @@ from .datetime_utils import serialize_datetime
 from .file import File, convert_file_dict_to_httpx_tuples
 from .http_client import AsyncHttpClient, HttpClient
 from .jsonable_encoder import jsonable_encoder
-from .pydantic_utilities import pydantic_v1
+from .pydantic_utilities import deep_union_pydantic_dicts, pydantic_v1
+from .query_encoder import encode_query
 from .remove_none_from_dict import remove_none_from_dict
 from .request_options import RequestOptions
 
@@ -20,6 +21,8 @@ __all__ = [
     "RequestOptions",
     "SyncClientWrapper",
     "convert_file_dict_to_httpx_tuples",
+    "deep_union_pydantic_dicts",
+    "encode_query",
     "jsonable_encoder",
     "pydantic_v1",
     "remove_none_from_dict",

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/core/client_wrapper.py

@@ -17,7 +17,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "athena-intelligence",
-            "X-Fern-SDK-Version": "0.1.83",
+            "X-Fern-SDK-Version": "0.1.84",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

athena_intelligence-0.1.84/src/athena/core/pydantic_utilities.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+
+IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+
+if IS_PYDANTIC_V2:
+    import pydantic.v1 as pydantic_v1  # type: ignore  # nopycln: import
+else:
+    import pydantic as pydantic_v1  # type: ignore  # nopycln: import
+
+
+def deep_union_pydantic_dicts(
+    source: typing.Dict[str, typing.Any], destination: typing.Dict[str, typing.Any]
+) -> typing.Dict[str, typing.Any]:
+    for key, value in source.items():
+        if isinstance(value, dict):
+            node = destination.setdefault(key, {})
+            deep_union_pydantic_dicts(value, node)
+        else:
+            destination[key] = value
+
+    return destination
+
+
+__all__ = ["pydantic_v1"]

athena_intelligence-0.1.84/src/athena/core/query_encoder.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from collections import ChainMap
+from typing import Any, Dict, Optional
+
+from .pydantic_utilities import pydantic_v1
+
+
+# Flattens dicts to be of the form {"key[subkey][subkey2]": value} where value is not a dict
+def traverse_query_dict(dict_flat: Dict[str, Any], key_prefix: Optional[str] = None) -> Dict[str, Any]:
+    result = {}
+    for k, v in dict_flat.items():
+        key = f"{key_prefix}[{k}]" if key_prefix is not None else k
+        if isinstance(v, dict):
+            result.update(traverse_query_dict(v, key))
+        else:
+            result[key] = v
+    return result
+
+
+def single_query_encoder(query_key: str, query_value: Any) -> Dict[str, Any]:
+    if isinstance(query_value, pydantic_v1.BaseModel) or isinstance(query_value, dict):
+        if isinstance(query_value, pydantic_v1.BaseModel):
+            obj_dict = query_value.dict(by_alias=True)
+        else:
+            obj_dict = query_value
+        return traverse_query_dict(obj_dict, query_key)
+
+    return {query_key: query_value}
+
+
+def encode_query(query: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    return dict(ChainMap(*[single_query_encoder(k, v) for k, v in query.items()])) if query is not None else None

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/dataset/client.py

@@ -8,6 +8,7 @@ from ..core.api_error import ApiError
 from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.jsonable_encoder import jsonable_encoder
 from ..core.pydantic_utilities import pydantic_v1
+from ..core.query_encoder import encode_query
 from ..core.remove_none_from_dict import remove_none_from_dict
 from ..core.request_options import RequestOptions
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
@@ -55,17 +56,19 @@ class DatasetClient:
         _response = self._client_wrapper.httpx_client.request(
             method="GET",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/datasets"),
-            params=jsonable_encoder(
-                remove_none_from_dict(
-                    {
-                        "page": page,
-                        "page_size": page_size,
-                        **(
-                            request_options.get("additional_query_parameters", {})
-                            if request_options is not None
-                            else {}
-                        ),
-                    }
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        {
+                            "page": page,
+                            "page_size": page_size,
+                            **(
+                                request_options.get("additional_query_parameters", {})
+                                if request_options is not None
+                                else {}
+                            ),
+                        }
+                    )
                 )
             ),
             headers=jsonable_encoder(
@@ -135,17 +138,19 @@ class AsyncDatasetClient:
         _response = await self._client_wrapper.httpx_client.request(
             method="GET",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/datasets"),
-            params=jsonable_encoder(
-                remove_none_from_dict(
-                    {
-                        "page": page,
-                        "page_size": page_size,
-                        **(
-                            request_options.get("additional_query_parameters", {})
-                            if request_options is not None
-                            else {}
-                        ),
-                    }
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        {
+                            "page": page,
+                            "page_size": page_size,
+                            **(
+                                request_options.get("additional_query_parameters", {})
+                                if request_options is not None
+                                else {}
+                            ),
+                        }
+                    )
                 )
             ),
             headers=jsonable_encoder(

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/message/client.py

@@ -8,6 +8,7 @@ from ..core.api_error import ApiError
 from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.jsonable_encoder import jsonable_encoder
 from ..core.pydantic_utilities import pydantic_v1
+from ..core.query_encoder import encode_query
 from ..core.remove_none_from_dict import remove_none_from_dict
 from ..core.request_options import RequestOptions
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
@@ -82,8 +83,10 @@ class MessageClient:
         _response = self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/message"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder(_request)
             if request_options is None or request_options.get("additional_body_parameters") is None
@@ -147,8 +150,10 @@ class MessageClient:
             url=urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/", f"api/v0/message/{jsonable_encoder(id)}"
             ),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             headers=jsonable_encoder(
                 remove_none_from_dict(
@@ -238,8 +243,10 @@ class AsyncMessageClient:
         _response = await self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/message"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder(_request)
             if request_options is None or request_options.get("additional_body_parameters") is None
@@ -303,8 +310,10 @@ class AsyncMessageClient:
             url=urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/", f"api/v0/message/{jsonable_encoder(id)}"
             ),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             headers=jsonable_encoder(
                 remove_none_from_dict(

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/query/client.py

@@ -8,6 +8,7 @@ from ..core.api_error import ApiError
 from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.jsonable_encoder import jsonable_encoder
 from ..core.pydantic_utilities import pydantic_v1
+from ..core.query_encoder import encode_query
 from ..core.remove_none_from_dict import remove_none_from_dict
 from ..core.request_options import RequestOptions
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
@@ -55,8 +56,10 @@ class QueryClient:
         _response = self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/execute-sql"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder({"sql_command": sql_command, "database_id": database_id})
             if request_options is None or request_options.get("additional_body_parameters") is None
@@ -128,8 +131,10 @@ class AsyncQueryClient:
         _response = await self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/execute-sql"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder({"sql_command": sql_command, "database_id": database_id})
             if request_options is None or request_options.get("additional_body_parameters") is None

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/report/client.py

@@ -8,6 +8,7 @@ from ..core.api_error import ApiError
 from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.jsonable_encoder import jsonable_encoder
 from ..core.pydantic_utilities import pydantic_v1
+from ..core.query_encoder import encode_query
 from ..core.remove_none_from_dict import remove_none_from_dict
 from ..core.request_options import RequestOptions
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
@@ -61,8 +62,10 @@ class ReportClient:
         _response = self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/report"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder(_request)
             if request_options is None or request_options.get("additional_body_parameters") is None
@@ -140,8 +143,10 @@ class AsyncReportClient:
         _response = await self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/report"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder(_request)
             if request_options is None or request_options.get("additional_body_parameters") is None

{athena_intelligence-0.1.83 → athena_intelligence-0.1.84}/src/athena/search/client.py

@@ -8,6 +8,7 @@ from ..core.api_error import ApiError
 from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.jsonable_encoder import jsonable_encoder
 from ..core.pydantic_utilities import pydantic_v1
+from ..core.query_encoder import encode_query
 from ..core.remove_none_from_dict import remove_none_from_dict
 from ..core.request_options import RequestOptions
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
@@ -79,8 +80,10 @@ class SearchClient:
         _response = self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/tools/search/get-urls"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder(_request)
             if request_options is None or request_options.get("additional_body_parameters") is None
@@ -176,8 +179,10 @@ class AsyncSearchClient:
         _response = await self._client_wrapper.httpx_client.request(
             method="POST",
             url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/tools/search/get-urls"),
-            params=jsonable_encoder(
-                request_options.get("additional_query_parameters") if request_options is not None else None
+            params=encode_query(
+                jsonable_encoder(
+                    request_options.get("additional_query_parameters") if request_options is not None else None
+                )
             ),
             json=jsonable_encoder(_request)
             if request_options is None or request_options.get("additional_body_parameters") is None