athena-intelligence 0.1.78__tar.gz → 0.1.80__tar.gz

{athena_intelligence-0.1.78 → athena_intelligence-0.1.80}/PKG-INFO

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

{athena_intelligence-0.1.78 → athena_intelligence-0.1.80}/pyproject.toml

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

{athena_intelligence-0.1.78 → athena_intelligence-0.1.80}/src/athena/__init__.py

@@ -2,10 +2,16 @@
 
 from .types import (
     ConvertPdfToSheetOut,
+    DataFrameParsingError,
+    DataFrameRequestOut,
+    DataFrameRequestOutColumnsItem,
+    DataFrameRequestOutDataItemItem,
+    DataFrameRequestOutIndexItem,
     Dataset,
     Document,
     ExcecuteToolFirstWorkflowOut,
     FileDataResponse,
+    FileFetchError,
     FilterModel,
     FilterOperator,
     FirecrawlScrapeUrlDataReponseDto,
@@ -37,18 +43,25 @@ from .types import (
     ValidationErrorLocItem,
     WorkflowStatusOut,
 )
-from .errors import UnprocessableEntityError
+from .errors import InternalServerError, NotFoundError, UnprocessableEntityError
 from . import chain, dataset, message, query, report, search, snippet, tools, upload, workflow
 from .environment import AthenaEnvironment
+from .tools import ToolsDataFrameRequestColumnsItem
 from .version import __version__
 
 __all__ = [
     "AthenaEnvironment",
     "ConvertPdfToSheetOut",
+    "DataFrameParsingError",
+    "DataFrameRequestOut",
+    "DataFrameRequestOutColumnsItem",
+    "DataFrameRequestOutDataItemItem",
+    "DataFrameRequestOutIndexItem",
     "Dataset",
     "Document",
     "ExcecuteToolFirstWorkflowOut",
     "FileDataResponse",
+    "FileFetchError",
     "FilterModel",
     "FilterOperator",
     "FirecrawlScrapeUrlDataReponseDto",
@@ -57,12 +70,14 @@ __all__ = [
     "GetSnippetOut",
     "GetSnippetsResponse",
     "HttpValidationError",
+    "InternalServerError",
     "LangchainDocumentsRequestOut",
     "LlmModel",
     "MapReduceChainOut",
     "MessageOut",
     "MessageOutDto",
     "Model",
+    "NotFoundError",
     "PublishFormats",
     "QueryModel",
     "Report",
@@ -74,6 +89,7 @@ __all__ = [
     "StructuredParseResult",
     "TimeDimensionModel",
     "Tools",
+    "ToolsDataFrameRequestColumnsItem",
     "UnprocessableEntityError",
     "UploadDocumentsOut",
     "UrlResult",

{athena_intelligence-0.1.78 → athena_intelligence-0.1.80}/src/athena/chain/client.py

@@ -50,7 +50,7 @@ class ChainClient:
             api_key="YOUR_API_KEY",
         )
         client.chain.structured_parse(
-            text_input='Athena is an AI-native analytics platform and artificial employee built to accelerate analytics workflows \n                by offering enterprise teams co-pilot and auto-pilot modes. Athena learns your workflow as a co-pilot, \n                allowing you to hand over controls to her for autonomous execution with confidence." \n                \n                Give me all of the modes Athena provides.',
+            text_input='Athena is an AI-native analytics platform and artificial employee built to accelerate analytics workflows\n                by offering enterprise teams co-pilot and auto-pilot modes. Athena learns your workflow as a co-pilot,\n                allowing you to hand over controls to her for autonomous execution with confidence."\n\n                Give me all of the modes Athena provides.',
             custom_type_dict={"modes": {}},
             model=LlmModel.GPT_4_TURBO,
         )
@@ -219,7 +219,7 @@ class AsyncChainClient:
             api_key="YOUR_API_KEY",
         )
         await client.chain.structured_parse(
-            text_input='Athena is an AI-native analytics platform and artificial employee built to accelerate analytics workflows \n                by offering enterprise teams co-pilot and auto-pilot modes. Athena learns your workflow as a co-pilot, \n                allowing you to hand over controls to her for autonomous execution with confidence." \n                \n                Give me all of the modes Athena provides.',
+            text_input='Athena is an AI-native analytics platform and artificial employee built to accelerate analytics workflows\n                by offering enterprise teams co-pilot and auto-pilot modes. Athena learns your workflow as a co-pilot,\n                allowing you to hand over controls to her for autonomous execution with confidence."\n\n                Give me all of the modes Athena provides.',
             custom_type_dict={"modes": {}},
             model=LlmModel.GPT_4_TURBO,
         )

{athena_intelligence-0.1.78 → athena_intelligence-0.1.80}/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.78",
+            "X-Fern-SDK-Version": "0.1.80",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

athena_intelligence-0.1.80/src/athena/errors/__init__.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .internal_server_error import InternalServerError
+from .not_found_error import NotFoundError
+from .unprocessable_entity_error import UnprocessableEntityError
+
+__all__ = ["InternalServerError", "NotFoundError", "UnprocessableEntityError"]

athena_intelligence-0.1.80/src/athena/errors/internal_server_error.py

@@ -0,0 +1,9 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.api_error import ApiError
+from ..types.data_frame_parsing_error import DataFrameParsingError
+
+
+class InternalServerError(ApiError):
+    def __init__(self, body: DataFrameParsingError):
+        super().__init__(status_code=500, body=body)

athena_intelligence-0.1.80/src/athena/errors/not_found_error.py

@@ -0,0 +1,9 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.api_error import ApiError
+from ..types.file_fetch_error import FileFetchError
+
+
+class NotFoundError(ApiError):
+    def __init__(self, body: FileFetchError):
+        super().__init__(status_code=404, body=body)

athena_intelligence-0.1.80/src/athena/tools/__init__.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .types import ToolsDataFrameRequestColumnsItem
+
+__all__ = ["ToolsDataFrameRequestColumnsItem"]

{athena_intelligence-0.1.78 → athena_intelligence-0.1.80}/src/athena/tools/client.py

@@ -10,9 +10,14 @@ from ..core.jsonable_encoder import jsonable_encoder
 from ..core.pydantic_utilities import pydantic_v1
 from ..core.remove_none_from_dict import remove_none_from_dict
 from ..core.request_options import RequestOptions
+from ..errors.internal_server_error import InternalServerError
+from ..errors.not_found_error import NotFoundError
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
 from ..types.convert_pdf_to_sheet_out import ConvertPdfToSheetOut
+from ..types.data_frame_parsing_error import DataFrameParsingError
+from ..types.data_frame_request_out import DataFrameRequestOut
 from ..types.excecute_tool_first_workflow_out import ExcecuteToolFirstWorkflowOut
+from ..types.file_fetch_error import FileFetchError
 from ..types.firecrawl_scrape_url_data_reponse_dto import FirecrawlScrapeUrlDataReponseDto
 from ..types.http_validation_error import HttpValidationError
 from ..types.langchain_documents_request_out import LangchainDocumentsRequestOut
@@ -21,6 +26,7 @@ from ..types.publish_formats import PublishFormats
 from ..types.query_model import QueryModel
 from ..types.researcher_out import ResearcherOut
 from ..types.semantic_query_out import SemanticQueryOut
+from .types.tools_data_frame_request_columns_item import ToolsDataFrameRequestColumnsItem
 
 # this is used as the default value for optional parameters
 OMIT = typing.cast(typing.Any, ...)
@@ -51,7 +57,7 @@ class ToolsClient:
             api_key="YOUR_API_KEY",
         )
         client.tools.scrape_url(
-            url="https://athenaintelligence.ai",
+            url="https://www.athenaintelligence.ai",
         )
         """
         _request: typing.Dict[str, typing.Any] = {"url": url}
@@ -169,6 +175,153 @@ class ToolsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
+    def data_frame(
+        self,
+        *,
+        document_id: str,
+        row_limit: typing.Optional[int] = None,
+        index_column: typing.Optional[int] = None,
+        columns: typing.Optional[
+            typing.Union[ToolsDataFrameRequestColumnsItem, typing.Sequence[ToolsDataFrameRequestColumnsItem]]
+        ] = None,
+        sheet_name: typing.Optional[str] = None,
+        separator: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> DataFrameRequestOut:
+        """
+        Parameters:
+            - document_id: str.
+
+            - row_limit: typing.Optional[int].
+
+            - index_column: typing.Optional[int].
+
+            - columns: typing.Optional[typing.Union[ToolsDataFrameRequestColumnsItem, typing.Sequence[ToolsDataFrameRequestColumnsItem]]]. should be a list of strings or a list of integers
+
+            - sheet_name: typing.Optional[str]. only for excel files
+
+            - separator: typing.Optional[str]. only for csv files
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import Athena
+
+        client = Athena(
+            api_key="YOUR_API_KEY",
+        )
+        client.tools.data_frame(
+            document_id="document_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            method="GET",
+            url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/tools/file/data-frame"),
+            params=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        "document_id": document_id,
+                        "row_limit": row_limit,
+                        "index_column": index_column,
+                        "columns": columns,
+                        "sheet_name": sheet_name,
+                        "separator": separator,
+                        **(
+                            request_options.get("additional_query_parameters", {})
+                            if request_options is not None
+                            else {}
+                        ),
+                    }
+                )
+            ),
+            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 self._client_wrapper.get_timeout(),
+            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_v1.parse_obj_as(DataFrameRequestOut, _response.json())  # type: ignore
+        if _response.status_code == 404:
+            raise NotFoundError(pydantic_v1.parse_obj_as(FileFetchError, _response.json()))  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(
+                pydantic_v1.parse_obj_as(HttpValidationError, _response.json())  # type: ignore
+            )
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic_v1.parse_obj_as(DataFrameParsingError, _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 raw_data(self, *, document_id: str, request_options: typing.Optional[RequestOptions] = None) -> None:
+        """
+        Parameters:
+            - document_id: str.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import Athena
+
+        client = Athena(
+            api_key="YOUR_API_KEY",
+        )
+        client.tools.raw_data(
+            document_id="document_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            method="GET",
+            url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/tools/file/raw-data"),
+            params=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        "document_id": document_id,
+                        **(
+                            request_options.get("additional_query_parameters", {})
+                            if request_options is not None
+                            else {}
+                        ),
+                    }
+                )
+            ),
+            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 self._client_wrapper.get_timeout(),
+            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
+        if _response.status_code == 404:
+            raise NotFoundError(pydantic_v1.parse_obj_as(FileFetchError, _response.json()))  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(
+                pydantic_v1.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 tool_first_workflow(
         self,
         *,
@@ -510,7 +663,7 @@ class AsyncToolsClient:
             api_key="YOUR_API_KEY",
         )
         await client.tools.scrape_url(
-            url="https://athenaintelligence.ai",
+            url="https://www.athenaintelligence.ai",
         )
         """
         _request: typing.Dict[str, typing.Any] = {"url": url}
@@ -628,6 +781,153 @@ class AsyncToolsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
+    async def data_frame(
+        self,
+        *,
+        document_id: str,
+        row_limit: typing.Optional[int] = None,
+        index_column: typing.Optional[int] = None,
+        columns: typing.Optional[
+            typing.Union[ToolsDataFrameRequestColumnsItem, typing.Sequence[ToolsDataFrameRequestColumnsItem]]
+        ] = None,
+        sheet_name: typing.Optional[str] = None,
+        separator: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> DataFrameRequestOut:
+        """
+        Parameters:
+            - document_id: str.
+
+            - row_limit: typing.Optional[int].
+
+            - index_column: typing.Optional[int].
+
+            - columns: typing.Optional[typing.Union[ToolsDataFrameRequestColumnsItem, typing.Sequence[ToolsDataFrameRequestColumnsItem]]]. should be a list of strings or a list of integers
+
+            - sheet_name: typing.Optional[str]. only for excel files
+
+            - separator: typing.Optional[str]. only for csv files
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import AsyncAthena
+
+        client = AsyncAthena(
+            api_key="YOUR_API_KEY",
+        )
+        await client.tools.data_frame(
+            document_id="document_id",
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            method="GET",
+            url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/tools/file/data-frame"),
+            params=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        "document_id": document_id,
+                        "row_limit": row_limit,
+                        "index_column": index_column,
+                        "columns": columns,
+                        "sheet_name": sheet_name,
+                        "separator": separator,
+                        **(
+                            request_options.get("additional_query_parameters", {})
+                            if request_options is not None
+                            else {}
+                        ),
+                    }
+                )
+            ),
+            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 self._client_wrapper.get_timeout(),
+            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_v1.parse_obj_as(DataFrameRequestOut, _response.json())  # type: ignore
+        if _response.status_code == 404:
+            raise NotFoundError(pydantic_v1.parse_obj_as(FileFetchError, _response.json()))  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(
+                pydantic_v1.parse_obj_as(HttpValidationError, _response.json())  # type: ignore
+            )
+        if _response.status_code == 500:
+            raise InternalServerError(pydantic_v1.parse_obj_as(DataFrameParsingError, _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 raw_data(self, *, document_id: str, request_options: typing.Optional[RequestOptions] = None) -> None:
+        """
+        Parameters:
+            - document_id: str.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import AsyncAthena
+
+        client = AsyncAthena(
+            api_key="YOUR_API_KEY",
+        )
+        await client.tools.raw_data(
+            document_id="document_id",
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            method="GET",
+            url=urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/tools/file/raw-data"),
+            params=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        "document_id": document_id,
+                        **(
+                            request_options.get("additional_query_parameters", {})
+                            if request_options is not None
+                            else {}
+                        ),
+                    }
+                )
+            ),
+            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 self._client_wrapper.get_timeout(),
+            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
+        if _response.status_code == 404:
+            raise NotFoundError(pydantic_v1.parse_obj_as(FileFetchError, _response.json()))  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(
+                pydantic_v1.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 tool_first_workflow(
         self,
         *,

athena_intelligence-0.1.80/src/athena/tools/types/__init__.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .tools_data_frame_request_columns_item import ToolsDataFrameRequestColumnsItem
+
+__all__ = ["ToolsDataFrameRequestColumnsItem"]

athena_intelligence-0.1.80/src/athena/tools/types/tools_data_frame_request_columns_item.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+ToolsDataFrameRequestColumnsItem = typing.Union[int, str]

{athena_intelligence-0.1.78 → athena_intelligence-0.1.80}/src/athena/types/__init__.py

@@ -1,10 +1,16 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from .convert_pdf_to_sheet_out import ConvertPdfToSheetOut
+from .data_frame_parsing_error import DataFrameParsingError
+from .data_frame_request_out import DataFrameRequestOut
+from .data_frame_request_out_columns_item import DataFrameRequestOutColumnsItem
+from .data_frame_request_out_data_item_item import DataFrameRequestOutDataItemItem
+from .data_frame_request_out_index_item import DataFrameRequestOutIndexItem
 from .dataset import Dataset
 from .document import Document
 from .excecute_tool_first_workflow_out import ExcecuteToolFirstWorkflowOut
 from .file_data_response import FileDataResponse
+from .file_fetch_error import FileFetchError
 from .filter_model import FilterModel
 from .filter_operator import FilterOperator
 from .firecrawl_scrape_url_data_reponse_dto import FirecrawlScrapeUrlDataReponseDto
@@ -38,10 +44,16 @@ from .workflow_status_out import WorkflowStatusOut
 
 __all__ = [
     "ConvertPdfToSheetOut",
+    "DataFrameParsingError",
+    "DataFrameRequestOut",
+    "DataFrameRequestOutColumnsItem",
+    "DataFrameRequestOutDataItemItem",
+    "DataFrameRequestOutIndexItem",
     "Dataset",
     "Document",
     "ExcecuteToolFirstWorkflowOut",
     "FileDataResponse",
+    "FileFetchError",
     "FilterModel",
     "FilterOperator",
     "FirecrawlScrapeUrlDataReponseDto",

athena_intelligence-0.1.80/src/athena/types/data_frame_parsing_error.py

@@ -0,0 +1,26 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
+
+
+class DataFrameParsingError(pydantic_v1.BaseModel):
+    message: str
+    document_id: str
+
+    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
+        extra = pydantic_v1.Extra.allow
+        json_encoders = {dt.datetime: serialize_datetime}

athena_intelligence-0.1.80/src/athena/types/data_frame_request_out.py

@@ -0,0 +1,30 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
+from .data_frame_request_out_columns_item import DataFrameRequestOutColumnsItem
+from .data_frame_request_out_data_item_item import DataFrameRequestOutDataItemItem
+from .data_frame_request_out_index_item import DataFrameRequestOutIndexItem
+
+
+class DataFrameRequestOut(pydantic_v1.BaseModel):
+    columns: typing.List[DataFrameRequestOutColumnsItem]
+    index: typing.List[DataFrameRequestOutIndexItem]
+    data: typing.List[typing.List[DataFrameRequestOutDataItemItem]]
+
+    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
+        extra = pydantic_v1.Extra.allow
+        json_encoders = {dt.datetime: serialize_datetime}

athena_intelligence-0.1.80/src/athena/types/data_frame_request_out_columns_item.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+DataFrameRequestOutColumnsItem = typing.Union[str, int, float]

athena_intelligence-0.1.80/src/athena/types/data_frame_request_out_data_item_item.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+DataFrameRequestOutDataItemItem = typing.Union[str, int, float]

athena_intelligence-0.1.80/src/athena/types/data_frame_request_out_index_item.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+DataFrameRequestOutIndexItem = typing.Union[str, int, float]

athena_intelligence-0.1.80/src/athena/types/file_fetch_error.py

@@ -0,0 +1,26 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+from ..core.pydantic_utilities import pydantic_v1
+
+
+class FileFetchError(pydantic_v1.BaseModel):
+    message: str
+    status_code: typing.Optional[int] = None
+
+    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
+        extra = pydantic_v1.Extra.allow
+        json_encoders = {dt.datetime: serialize_datetime}

{athena_intelligence-0.1.78 → athena_intelligence-0.1.80}/src/athena/types/query_model.py

@@ -16,6 +16,7 @@ class QueryModel(pydantic_v1.BaseModel):
     )
     dimensions: typing.Optional[typing.List[str]] = None
     filters: typing.Optional[typing.List[FilterModel]] = None
+    limit: typing.Optional[int] = None
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

athena_intelligence-0.1.78/src/athena/errors/__init__.py

@@ -1,5 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from .unprocessable_entity_error import UnprocessableEntityError
-
-__all__ = ["UnprocessableEntityError"]

athena_intelligence-0.1.78/src/athena/workflow/__init__.py

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