athena-intelligence 0.1.94__py3-none-any.whl → 0.1.96__py3-none-any.whl

athena/tools/client.py

@@ -11,145 +11,18 @@ from ..errors.internal_server_error import InternalServerError
 from ..errors.not_found_error import NotFoundError
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
 from ..errors.unsupported_media_type_error import UnsupportedMediaTypeError
-from ..types.athena_document_v_2_out import AthenaDocumentV2Out
-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.data_frame_unknown_format_error import DataFrameUnknownFormatError
-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
-from ..types.llm_model import LlmModel
-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, ...)
-
 
 class ToolsClient:
     def __init__(self, *, client_wrapper: SyncClientWrapper):
         self._client_wrapper = client_wrapper
 
-    def scrape_url(
-        self,
-        *,
-        url: str,
-        params: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> FirecrawlScrapeUrlDataReponseDto:
-        """
-        Parameters
-        ----------
-        url : str
-
-        params : typing.Optional[typing.Dict[str, typing.Any]]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        FirecrawlScrapeUrlDataReponseDto
-            Successful Response
-
-        Examples
-        --------
-        from athena.client import Athena
-
-        client = Athena(
-            api_key="YOUR_API_KEY",
-        )
-        client.tools.scrape_url(
-            url="https://www.athenaintelligence.ai",
-            params={"key": "value"},
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "api/v0/tools/firecrawl/scrape-url",
-            method="POST",
-            json={"url": url, "params": params},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(FirecrawlScrapeUrlDataReponseDto, _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 langchain_documents(
-        self,
-        *,
-        document_id: str,
-        pagination_limit: typing.Optional[int] = OMIT,
-        pagination_offset: typing.Optional[int] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> LangchainDocumentsRequestOut:
-        """
-        Parameters
-        ----------
-        document_id : str
-
-        pagination_limit : typing.Optional[int]
-
-        pagination_offset : typing.Optional[int]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        LangchainDocumentsRequestOut
-            Successful Response
-
-        Examples
-        --------
-        from athena.client import Athena
-
-        client = Athena(
-            api_key="YOUR_API_KEY",
-        )
-        client.tools.langchain_documents(
-            document_id="doc_9249292-d118-42d3-95b4-00eccfe0754f",
-            pagination_limit=250,
-            pagination_offset=0,
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "api/v0/tools/file/langchain-documents",
-            method="POST",
-            json={
-                "document_id": document_id,
-                "pagination_limit": pagination_limit,
-                "pagination_offset": pagination_offset,
-            },
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(LangchainDocumentsRequestOut, _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 data_frame(
         self,
         *,
@@ -159,7 +32,7 @@ class ToolsClient:
         columns: typing.Optional[
             typing.Union[ToolsDataFrameRequestColumnsItem, typing.Sequence[ToolsDataFrameRequestColumnsItem]]
         ] = None,
-        sheet_name: typing.Optional[int] = None,
+        sheet_name: typing.Optional[str] = None,
         separator: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None
     ) -> DataFrameRequestOut:
@@ -175,7 +48,7 @@ class ToolsClient:
         columns : typing.Optional[typing.Union[ToolsDataFrameRequestColumnsItem, typing.Sequence[ToolsDataFrameRequestColumnsItem]]]
             should be a list of strings or a list of integers
 
-        sheet_name : typing.Optional[int]
+        sheet_name : typing.Optional[str]
             only for excel files
 
         separator : typing.Optional[str]
@@ -237,6 +110,8 @@ class ToolsClient:
         self, *, document_id: str, request_options: typing.Optional[RequestOptions] = None
     ) -> typing.Iterator[bytes]:
         """
+        Get the raw file data for given asset.
+
         Parameters
         ----------
         document_id : str
@@ -283,273 +158,100 @@ class ToolsClient:
                 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,
-        *,
-        tool_name: str,
-        content: str,
-        model: typing.Optional[LlmModel] = OMIT,
-        tool_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> ExcecuteToolFirstWorkflowOut:
-        """
-        Parameters
-        ----------
-        tool_name : str
-
-        content : str
-
-        model : typing.Optional[LlmModel]
-
-        tool_kwargs : typing.Optional[typing.Dict[str, typing.Any]]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        ExcecuteToolFirstWorkflowOut
-            Successful Response
-
-        Examples
-        --------
-        from athena import LlmModel
-        from athena.client import Athena
 
-        client = Athena(
-            api_key="YOUR_API_KEY",
-        )
-        client.tools.tool_first_workflow(
-            model=LlmModel.MISTRAL_LARGE_0224,
-            tool_name="tavily_search",
-            content="summarize the website in one paragraph",
-            tool_kwargs={"query": "website: www.athenaintelligence.ai"},
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "api/v0/tools/first-agent",
-            method="POST",
-            json={"model": model, "tool_name": tool_name, "content": content, "tool_kwargs": tool_kwargs},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(ExcecuteToolFirstWorkflowOut, _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)
+class AsyncToolsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
 
-    def researcher(
+    async def data_frame(
         self,
         *,
-        query: str,
-        max_sections: int,
-        guidelines: typing.Sequence[str],
-        publish_formats: typing.Optional[PublishFormats] = OMIT,
-        source: typing.Optional[str] = OMIT,
-        athena_document_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        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
-    ) -> ResearcherOut:
+    ) -> DataFrameRequestOut:
         """
         Parameters
         ----------
-        query : str
+        document_id : str
 
-        max_sections : int
+        row_limit : typing.Optional[int]
 
-        guidelines : typing.Sequence[str]
+        index_column : typing.Optional[int]
 
-        publish_formats : typing.Optional[PublishFormats]
+        columns : typing.Optional[typing.Union[ToolsDataFrameRequestColumnsItem, typing.Sequence[ToolsDataFrameRequestColumnsItem]]]
+            should be a list of strings or a list of integers
 
-        source : typing.Optional[str]
+        sheet_name : typing.Optional[str]
+            only for excel files
 
-        athena_document_ids : typing.Optional[typing.Sequence[str]]
+        separator : typing.Optional[str]
+            only for csv files
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        ResearcherOut
+        DataFrameRequestOut
             Successful Response
 
         Examples
         --------
-        from athena import PublishFormats
-        from athena.client import Athena
+        from athena.client import AsyncAthena
 
-        client = Athena(
+        client = AsyncAthena(
             api_key="YOUR_API_KEY",
         )
-        client.tools.researcher(
-            query="Write a report about the company Athena Intelligence.",
-            max_sections=10,
-            guidelines=[
-                "The report MUST be written in APA format",
-                "Each sub section MUST include supporting sources using hyperlinks. If none exist, erase the sub section or rewrite it to be a part of the previous section",
-                "The report MUST be written in english",
-            ],
-            publish_formats=PublishFormats(
-                markdown=False,
-                pdf=True,
-                docx=False,
-            ),
-            source="web",
-            athena_document_ids=["doc_1", "doc_2"],
+        await client.tools.data_frame(
+            document_id="document_id",
         )
         """
-        _response = self._client_wrapper.httpx_client.request(
-            "api/v0/tools/researcher",
-            method="POST",
-            json={
-                "query": query,
-                "max_sections": max_sections,
-                "guidelines": guidelines,
-                "publish_formats": publish_formats,
-                "source": source,
-                "athena_document_ids": athena_document_ids,
+        _response = await self._client_wrapper.httpx_client.request(
+            "api/v0/tools/file/data-frame",
+            method="GET",
+            params={
+                "document_id": document_id,
+                "row_limit": row_limit,
+                "index_column": index_column,
+                "columns": columns,
+                "sheet_name": sheet_name,
+                "separator": separator,
             },
             request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(ResearcherOut, _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 convert_pdf_to_sheet(
-        self, *, document_id: str, request_options: typing.Optional[RequestOptions] = None
-    ) -> ConvertPdfToSheetOut:
-        """
-        Parameters
-        ----------
-        document_id : str
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        ConvertPdfToSheetOut
-            Successful Response
-
-        Examples
-        --------
-        from athena.client import Athena
-
-        client = Athena(
-            api_key="YOUR_API_KEY",
-        )
-        client.tools.convert_pdf_to_sheet(
-            document_id="doc_9249292-d118-42d3-95b4-00eccfe0754f",
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "api/v0/tools/convert-pdf-to-sheet",
-            method="POST",
-            json={"document_id": document_id},
-            request_options=request_options,
-            omit=OMIT,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(ConvertPdfToSheetOut, _response.json())  # type: ignore
-        if _response.status_code == 422:
-            raise UnprocessableEntityError(
-                pydantic_v1.parse_obj_as(HttpValidationError, _response.json())  # type: ignore
+            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 == 415:
+            raise UnsupportedMediaTypeError(
+                pydantic_v1.parse_obj_as(DataFrameUnknownFormatError, _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 semantic_query(
-        self,
-        *,
-        query: QueryModel,
-        table_name: typing.Optional[str] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> SemanticQueryOut:
-        """
-        Parameters
-        ----------
-        query : QueryModel
-
-        table_name : typing.Optional[str]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        SemanticQueryOut
-            Successful Response
-
-        Examples
-        --------
-        from athena import FilterModel, FilterOperator, QueryModel, TimeDimensionModel
-        from athena.client import Athena
-
-        client = Athena(
-            api_key="YOUR_API_KEY",
-        )
-        client.tools.semantic_query(
-            query=QueryModel(
-                measures=["count"],
-                time_dimensions=[
-                    TimeDimensionModel(
-                        dimension="dimension",
-                        granularity="granularity",
-                        date_range=["dateRange"],
-                    )
-                ],
-                dimensions=["manufacturer"],
-                filters=[
-                    FilterModel(
-                        dimension="manufacturer",
-                        operator=FilterOperator.EQUALS,
-                        values=["Athena"],
-                    )
-                ],
-            ),
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "api/v0/tools/strict-semantic-query",
-            method="POST",
-            json={"query": query, "table_name": table_name},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(SemanticQueryOut, _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 athena_documents(
+    async def raw_data(
         self, *, document_id: str, request_options: typing.Optional[RequestOptions] = None
-    ) -> AthenaDocumentV2Out:
+    ) -> typing.AsyncIterator[bytes]:
         """
+        Get the raw file data for given asset.
+
         Parameters
         ----------
         document_id : str
@@ -557,268 +259,20 @@ class ToolsClient:
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
-        Returns
-        -------
-        AthenaDocumentV2Out
-            Successful Response
+        Yields
+        ------
+        typing.AsyncIterator[bytes]
+            Stream the file in original format.
 
         Examples
         --------
-        from athena.client import Athena
+        from athena.client import AsyncAthena
 
-        client = Athena(
+        client = AsyncAthena(
             api_key="YOUR_API_KEY",
         )
-        client.tools.athena_documents(
-            document_id="doc_9249292-d118-42d3-95b4-00eccfe0754f",
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "api/v0/tools/athena-document-v2",
-            method="POST",
-            json={"document_id": document_id},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(AthenaDocumentV2Out, _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)
-
-
-class AsyncToolsClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    async def scrape_url(
-        self,
-        *,
-        url: str,
-        params: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> FirecrawlScrapeUrlDataReponseDto:
-        """
-        Parameters
-        ----------
-        url : str
-
-        params : typing.Optional[typing.Dict[str, typing.Any]]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        FirecrawlScrapeUrlDataReponseDto
-            Successful Response
-
-        Examples
-        --------
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            api_key="YOUR_API_KEY",
-        )
-        await client.tools.scrape_url(
-            url="https://www.athenaintelligence.ai",
-            params={"key": "value"},
-        )
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "api/v0/tools/firecrawl/scrape-url",
-            method="POST",
-            json={"url": url, "params": params},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(FirecrawlScrapeUrlDataReponseDto, _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 langchain_documents(
-        self,
-        *,
-        document_id: str,
-        pagination_limit: typing.Optional[int] = OMIT,
-        pagination_offset: typing.Optional[int] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> LangchainDocumentsRequestOut:
-        """
-        Parameters
-        ----------
-        document_id : str
-
-        pagination_limit : typing.Optional[int]
-
-        pagination_offset : typing.Optional[int]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        LangchainDocumentsRequestOut
-            Successful Response
-
-        Examples
-        --------
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            api_key="YOUR_API_KEY",
-        )
-        await client.tools.langchain_documents(
-            document_id="doc_9249292-d118-42d3-95b4-00eccfe0754f",
-            pagination_limit=250,
-            pagination_offset=0,
-        )
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "api/v0/tools/file/langchain-documents",
-            method="POST",
-            json={
-                "document_id": document_id,
-                "pagination_limit": pagination_limit,
-                "pagination_offset": pagination_offset,
-            },
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(LangchainDocumentsRequestOut, _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 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[int] = 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[int]
-            only for excel files
-
-        separator : typing.Optional[str]
-            only for csv files
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        DataFrameRequestOut
-            Successful Response
-
-        Examples
-        --------
-        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(
-            "api/v0/tools/file/data-frame",
-            method="GET",
-            params={
-                "document_id": document_id,
-                "row_limit": row_limit,
-                "index_column": index_column,
-                "columns": columns,
-                "sheet_name": sheet_name,
-                "separator": separator,
-            },
-            request_options=request_options,
-        )
-        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 == 415:
-            raise UnsupportedMediaTypeError(
-                pydantic_v1.parse_obj_as(DataFrameUnknownFormatError, _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
-    ) -> typing.AsyncIterator[bytes]:
-        """
-        Parameters
-        ----------
-        document_id : str
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Yields
-        ------
-        typing.AsyncIterator[bytes]
-            Stream the file in original format.
-
-        Examples
-        --------
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            api_key="YOUR_API_KEY",
-        )
-        await client.tools.raw_data(
-            document_id="string",
+        await client.tools.raw_data(
+            document_id="string",
         )
         """
         async with self._client_wrapper.httpx_client.stream(
@@ -843,312 +297,3 @@ class AsyncToolsClient:
             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,
-        *,
-        tool_name: str,
-        content: str,
-        model: typing.Optional[LlmModel] = OMIT,
-        tool_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> ExcecuteToolFirstWorkflowOut:
-        """
-        Parameters
-        ----------
-        tool_name : str
-
-        content : str
-
-        model : typing.Optional[LlmModel]
-
-        tool_kwargs : typing.Optional[typing.Dict[str, typing.Any]]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        ExcecuteToolFirstWorkflowOut
-            Successful Response
-
-        Examples
-        --------
-        from athena import LlmModel
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            api_key="YOUR_API_KEY",
-        )
-        await client.tools.tool_first_workflow(
-            model=LlmModel.MISTRAL_LARGE_0224,
-            tool_name="tavily_search",
-            content="summarize the website in one paragraph",
-            tool_kwargs={"query": "website: www.athenaintelligence.ai"},
-        )
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "api/v0/tools/first-agent",
-            method="POST",
-            json={"model": model, "tool_name": tool_name, "content": content, "tool_kwargs": tool_kwargs},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(ExcecuteToolFirstWorkflowOut, _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 researcher(
-        self,
-        *,
-        query: str,
-        max_sections: int,
-        guidelines: typing.Sequence[str],
-        publish_formats: typing.Optional[PublishFormats] = OMIT,
-        source: typing.Optional[str] = OMIT,
-        athena_document_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> ResearcherOut:
-        """
-        Parameters
-        ----------
-        query : str
-
-        max_sections : int
-
-        guidelines : typing.Sequence[str]
-
-        publish_formats : typing.Optional[PublishFormats]
-
-        source : typing.Optional[str]
-
-        athena_document_ids : typing.Optional[typing.Sequence[str]]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        ResearcherOut
-            Successful Response
-
-        Examples
-        --------
-        from athena import PublishFormats
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            api_key="YOUR_API_KEY",
-        )
-        await client.tools.researcher(
-            query="Write a report about the company Athena Intelligence.",
-            max_sections=10,
-            guidelines=[
-                "The report MUST be written in APA format",
-                "Each sub section MUST include supporting sources using hyperlinks. If none exist, erase the sub section or rewrite it to be a part of the previous section",
-                "The report MUST be written in english",
-            ],
-            publish_formats=PublishFormats(
-                markdown=False,
-                pdf=True,
-                docx=False,
-            ),
-            source="web",
-            athena_document_ids=["doc_1", "doc_2"],
-        )
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "api/v0/tools/researcher",
-            method="POST",
-            json={
-                "query": query,
-                "max_sections": max_sections,
-                "guidelines": guidelines,
-                "publish_formats": publish_formats,
-                "source": source,
-                "athena_document_ids": athena_document_ids,
-            },
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(ResearcherOut, _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 convert_pdf_to_sheet(
-        self, *, document_id: str, request_options: typing.Optional[RequestOptions] = None
-    ) -> ConvertPdfToSheetOut:
-        """
-        Parameters
-        ----------
-        document_id : str
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        ConvertPdfToSheetOut
-            Successful Response
-
-        Examples
-        --------
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            api_key="YOUR_API_KEY",
-        )
-        await client.tools.convert_pdf_to_sheet(
-            document_id="doc_9249292-d118-42d3-95b4-00eccfe0754f",
-        )
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "api/v0/tools/convert-pdf-to-sheet",
-            method="POST",
-            json={"document_id": document_id},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(ConvertPdfToSheetOut, _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 semantic_query(
-        self,
-        *,
-        query: QueryModel,
-        table_name: typing.Optional[str] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None
-    ) -> SemanticQueryOut:
-        """
-        Parameters
-        ----------
-        query : QueryModel
-
-        table_name : typing.Optional[str]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        SemanticQueryOut
-            Successful Response
-
-        Examples
-        --------
-        from athena import FilterModel, FilterOperator, QueryModel, TimeDimensionModel
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            api_key="YOUR_API_KEY",
-        )
-        await client.tools.semantic_query(
-            query=QueryModel(
-                measures=["count"],
-                time_dimensions=[
-                    TimeDimensionModel(
-                        dimension="dimension",
-                        granularity="granularity",
-                        date_range=["dateRange"],
-                    )
-                ],
-                dimensions=["manufacturer"],
-                filters=[
-                    FilterModel(
-                        dimension="manufacturer",
-                        operator=FilterOperator.EQUALS,
-                        values=["Athena"],
-                    )
-                ],
-            ),
-        )
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "api/v0/tools/strict-semantic-query",
-            method="POST",
-            json={"query": query, "table_name": table_name},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(SemanticQueryOut, _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 athena_documents(
-        self, *, document_id: str, request_options: typing.Optional[RequestOptions] = None
-    ) -> AthenaDocumentV2Out:
-        """
-        Parameters
-        ----------
-        document_id : str
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        AthenaDocumentV2Out
-            Successful Response
-
-        Examples
-        --------
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            api_key="YOUR_API_KEY",
-        )
-        await client.tools.athena_documents(
-            document_id="doc_9249292-d118-42d3-95b4-00eccfe0754f",
-        )
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "api/v0/tools/athena-document-v2",
-            method="POST",
-            json={"document_id": document_id},
-            request_options=request_options,
-            omit=OMIT,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic_v1.parse_obj_as(AthenaDocumentV2Out, _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)