athena-intelligence 0.1.35__tar.gz → 0.1.37__tar.gz

{athena_intelligence-0.1.35 → athena_intelligence-0.1.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: athena-intelligence
-Version: 0.1.35
+Version: 0.1.37
 Summary: 
 Requires-Python: >=3.8,<4.0
 Classifier: Programming Language :: Python :: 3

{athena_intelligence-0.1.35 → athena_intelligence-0.1.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "athena-intelligence"
-version = "0.1.35"
+version = "0.1.37"
 description = ""
 readme = "README.md"
 authors = []

{athena_intelligence-0.1.35 → athena_intelligence-0.1.37}/src/athena/__init__.py

@@ -13,11 +13,12 @@ from .types import (
     SqlResults,
     StatusEnum,
     Tools,
+    UrlResult,
     ValidationError,
     ValidationErrorLocItem,
 )
 from .errors import UnprocessableEntityError
-from . import dataset, message, query, report, snippet
+from . import dataset, message, query, report, search, snippet
 from .environment import AthenaEnvironment
 
 __all__ = [
@@ -35,11 +36,13 @@ __all__ = [
     "StatusEnum",
     "Tools",
     "UnprocessableEntityError",
+    "UrlResult",
     "ValidationError",
     "ValidationErrorLocItem",
     "dataset",
     "message",
     "query",
     "report",
+    "search",
     "snippet",
 ]

{athena_intelligence-0.1.35 → athena_intelligence-0.1.37}/src/athena/base_client.py

@@ -10,6 +10,7 @@ from .environment import AthenaEnvironment
 from .message.client import AsyncMessageClient, MessageClient
 from .query.client import AsyncQueryClient, QueryClient
 from .report.client import AsyncReportClient, ReportClient
+from .search.client import AsyncSearchClient, SearchClient
 from .snippet.client import AsyncSnippetClient, SnippetClient
 
 
@@ -56,6 +57,7 @@ class BaseAthena:
         self.snippet = SnippetClient(client_wrapper=self._client_wrapper)
         self.report = ReportClient(client_wrapper=self._client_wrapper)
         self.query = QueryClient(client_wrapper=self._client_wrapper)
+        self.search = SearchClient(client_wrapper=self._client_wrapper)
 
 
 class AsyncBaseAthena:
@@ -101,6 +103,7 @@ class AsyncBaseAthena:
         self.snippet = AsyncSnippetClient(client_wrapper=self._client_wrapper)
         self.report = AsyncReportClient(client_wrapper=self._client_wrapper)
         self.query = AsyncQueryClient(client_wrapper=self._client_wrapper)
+        self.search = AsyncSearchClient(client_wrapper=self._client_wrapper)
 
 
 def _get_base_url(*, base_url: typing.Optional[str] = None, environment: AthenaEnvironment) -> str:

{athena_intelligence-0.1.35 → athena_intelligence-0.1.37}/src/athena/core/client_wrapper.py

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

athena_intelligence-0.1.37/src/athena/search/client.py

@@ -0,0 +1,298 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+import urllib.parse
+from json.decoder import JSONDecodeError
+
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.jsonable_encoder import jsonable_encoder
+from ..core.remove_none_from_dict import remove_none_from_dict
+from ..core.request_options import RequestOptions
+from ..errors.unprocessable_entity_error import UnprocessableEntityError
+from ..types.http_validation_error import HttpValidationError
+from ..types.url_result import UrlResult
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class SearchClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def get_urls(
+        self,
+        *,
+        query: str,
+        num_urls: int,
+        tbs: str,
+        country_code: typing.Optional[str] = OMIT,
+        country_restrict: typing.Optional[str] = OMIT,
+        site: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> UrlResult:
+        """
+        Parameters:
+            - query: str.
+
+            - num_urls: int.
+
+            - tbs: str.
+
+            - country_code: typing.Optional[str].
+
+            - country_restrict: typing.Optional[str].
+
+            - site: typing.Optional[str].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import Athena
+
+        client = Athena(
+            api_key="YOUR_API_KEY",
+        )
+        client.search.get_urls(
+            query="query",
+            num_urls=1,
+            tbs="tbs",
+        )
+        """
+        _request: typing.Dict[str, typing.Any] = {"query": query, "num_urls": num_urls, "tbs": tbs}
+        if country_code is not OMIT:
+            _request["country_code"] = country_code
+        if country_restrict is not OMIT:
+            _request["country_restrict"] = country_restrict
+        if site is not OMIT:
+            _request["site"] = site
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/get-urls"),
+            params=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
+            else {
+                **jsonable_encoder(_request),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else 60,
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(UrlResult, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def get_markdown(self, *, url: str, request_options: typing.Optional[RequestOptions] = None) -> UrlResult:
+        """
+        Parameters:
+            - url: str.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import Athena
+
+        client = Athena(
+            api_key="YOUR_API_KEY",
+        )
+        client.search.get_markdown(
+            url="url",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/get-markdown"),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            json=jsonable_encoder({"url": url})
+            if request_options is None or request_options.get("additional_body_parameters") is None
+            else {
+                **jsonable_encoder({"url": url}),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else 60,
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(UrlResult, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+
+class AsyncSearchClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def get_urls(
+        self,
+        *,
+        query: str,
+        num_urls: int,
+        tbs: str,
+        country_code: typing.Optional[str] = OMIT,
+        country_restrict: typing.Optional[str] = OMIT,
+        site: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> UrlResult:
+        """
+        Parameters:
+            - query: str.
+
+            - num_urls: int.
+
+            - tbs: str.
+
+            - country_code: typing.Optional[str].
+
+            - country_restrict: typing.Optional[str].
+
+            - site: typing.Optional[str].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import AsyncAthena
+
+        client = AsyncAthena(
+            api_key="YOUR_API_KEY",
+        )
+        await client.search.get_urls(
+            query="query",
+            num_urls=1,
+            tbs="tbs",
+        )
+        """
+        _request: typing.Dict[str, typing.Any] = {"query": query, "num_urls": num_urls, "tbs": tbs}
+        if country_code is not OMIT:
+            _request["country_code"] = country_code
+        if country_restrict is not OMIT:
+            _request["country_restrict"] = country_restrict
+        if site is not OMIT:
+            _request["site"] = site
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/get-urls"),
+            params=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
+            else {
+                **jsonable_encoder(_request),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else 60,
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(UrlResult, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def get_markdown(self, *, url: str, request_options: typing.Optional[RequestOptions] = None) -> UrlResult:
+        """
+        Parameters:
+            - url: str.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import AsyncAthena
+
+        client = AsyncAthena(
+            api_key="YOUR_API_KEY",
+        )
+        await client.search.get_markdown(
+            url="url",
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/get-markdown"),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            json=jsonable_encoder({"url": url})
+            if request_options is None or request_options.get("additional_body_parameters") is None
+            else {
+                **jsonable_encoder({"url": url}),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else 60,
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(UrlResult, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)

athena_intelligence-0.1.37/src/athena/snippet/__init__.py

@@ -0,0 +1,2 @@
+# This file was auto-generated by Fern from our API Definition.
+

{athena_intelligence-0.1.35 → athena_intelligence-0.1.37}/src/athena/types/__init__.py

@@ -12,6 +12,7 @@ from .snippet import Snippet
 from .sql_results import SqlResults
 from .status_enum import StatusEnum
 from .tools import Tools
+from .url_result import UrlResult
 from .validation_error import ValidationError
 from .validation_error_loc_item import ValidationErrorLocItem
 
@@ -28,6 +29,7 @@ __all__ = [
     "SqlResults",
     "StatusEnum",
     "Tools",
+    "UrlResult",
     "ValidationError",
     "ValidationErrorLocItem",
 ]

athena_intelligence-0.1.37/src/athena/types/url_result.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class UrlResult(pydantic.BaseModel):
+    result: typing.Dict[str, typing.Any]
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        json_encoders = {dt.datetime: serialize_datetime}