athena-intelligence 0.1.4__tar.gz → 0.1.5__tar.gz

{athena_intelligence-0.1.4 → athena_intelligence-0.1.5}/PKG-INFO

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

{athena_intelligence-0.1.4 → athena_intelligence-0.1.5}/pyproject.toml

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

athena_intelligence-0.1.5/src/athena/__init__.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .types import HttpValidationError, MessageOut, MessageOutDto, Model, Tools, ValidationError, ValidationErrorLocItem
+from .errors import UnprocessableEntityError
+from .environment import AthenaEnvironment
+
+__all__ = [
+    "AthenaEnvironment",
+    "HttpValidationError",
+    "MessageOut",
+    "MessageOutDto",
+    "Model",
+    "Tools",
+    "UnprocessableEntityError",
+    "ValidationError",
+    "ValidationErrorLocItem",
+]

athena_intelligence-0.1.5/src/athena/client.py

@@ -0,0 +1,419 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+import urllib.parse
+from json.decoder import JSONDecodeError
+
+import httpx
+
+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 .environment import AthenaEnvironment
+from .errors.unprocessable_entity_error import UnprocessableEntityError
+from .types.http_validation_error import HttpValidationError
+from .types.message_out import MessageOut
+from .types.message_out_dto import MessageOutDto
+from .types.model import Model
+from .types.tools import Tools
+
+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 Athena:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propogate to these functions.
+
+    Parameters:
+        - base_url: typing.Optional[str]. The base url to use for requests from the client.
+
+        - environment: AthenaEnvironment. The environment to use for requests from the client. from .environment import AthenaEnvironment
+
+                                          Defaults to AthenaEnvironment.DEFAULT
+
+        - timeout: typing.Optional[float]. The timeout to be used, in seconds, for requests by default the timeout is 60 seconds.
+
+        - httpx_client: typing.Optional[httpx.Client]. The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+    ---
+    from athena.client import Athena
+
+    client = Athena()
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: AthenaEnvironment = AthenaEnvironment.DEFAULT,
+        timeout: typing.Optional[float] = 60,
+        httpx_client: typing.Optional[httpx.Client] = None,
+    ):
+        self._client_wrapper = SyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            httpx_client=httpx.Client(timeout=timeout) if httpx_client is None else httpx_client,
+        )
+
+    def health_check(self, *, request_options: typing.Optional[RequestOptions] = None) -> typing.Any:
+        """
+        Checks the health of a project.
+
+        It returns 200 if the project is healthy.
+
+        Parameters:
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import Athena
+
+        client = Athena()
+        client.health_check()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/health"),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            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,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Any, _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_get_message(self, id: str, *, request_options: typing.Optional[RequestOptions] = None) -> MessageOutDto:
+        """
+        Parameters:
+            - id: str.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import Athena
+
+        client = Athena()
+        client.athena_get_message(
+            id="id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            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
+            ),
+            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,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(MessageOutDto, _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 post_message(
+        self,
+        *,
+        content: str,
+        model: typing.Optional[Model] = OMIT,
+        tools: typing.Optional[typing.Sequence[Tools]] = OMIT,
+        conversation_id: typing.Optional[str] = OMIT,
+        conversation_name: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> MessageOut:
+        """
+        Parameters:
+            - content: str.
+
+            - model: typing.Optional[Model].
+
+            - tools: typing.Optional[typing.Sequence[Tools]].
+
+            - conversation_id: typing.Optional[str].
+
+            - conversation_name: typing.Optional[str].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import Athena
+
+        client = Athena()
+        client.post_message(
+            content="content",
+        )
+        """
+        _request: typing.Dict[str, typing.Any] = {"content": content}
+        if model is not OMIT:
+            _request["model"] = model.value if model is not None else None
+        if tools is not OMIT:
+            _request["tools"] = tools
+        if conversation_id is not OMIT:
+            _request["conversation_id"] = conversation_id
+        if conversation_name is not OMIT:
+            _request["conversation_name"] = conversation_name
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            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
+            ),
+            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,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(MessageOut, _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 AsyncAthena:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propogate to these functions.
+
+    Parameters:
+        - base_url: typing.Optional[str]. The base url to use for requests from the client.
+
+        - environment: AthenaEnvironment. The environment to use for requests from the client. from .environment import AthenaEnvironment
+
+                                          Defaults to AthenaEnvironment.DEFAULT
+
+        - timeout: typing.Optional[float]. The timeout to be used, in seconds, for requests by default the timeout is 60 seconds.
+
+        - httpx_client: typing.Optional[httpx.AsyncClient]. The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+    ---
+    from athena.client import AsyncAthena
+
+    client = AsyncAthena()
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: AthenaEnvironment = AthenaEnvironment.DEFAULT,
+        timeout: typing.Optional[float] = 60,
+        httpx_client: typing.Optional[httpx.AsyncClient] = None,
+    ):
+        self._client_wrapper = AsyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            httpx_client=httpx.AsyncClient(timeout=timeout) if httpx_client is None else httpx_client,
+        )
+
+    async def health_check(self, *, request_options: typing.Optional[RequestOptions] = None) -> typing.Any:
+        """
+        Checks the health of a project.
+
+        It returns 200 if the project is healthy.
+
+        Parameters:
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import AsyncAthena
+
+        client = AsyncAthena()
+        await client.health_check()
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/health"),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            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,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Any, _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_get_message(
+        self, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> MessageOutDto:
+        """
+        Parameters:
+            - id: str.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import AsyncAthena
+
+        client = AsyncAthena()
+        await client.athena_get_message(
+            id="id",
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            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
+            ),
+            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,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(MessageOutDto, _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 post_message(
+        self,
+        *,
+        content: str,
+        model: typing.Optional[Model] = OMIT,
+        tools: typing.Optional[typing.Sequence[Tools]] = OMIT,
+        conversation_id: typing.Optional[str] = OMIT,
+        conversation_name: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> MessageOut:
+        """
+        Parameters:
+            - content: str.
+
+            - model: typing.Optional[Model].
+
+            - tools: typing.Optional[typing.Sequence[Tools]].
+
+            - conversation_id: typing.Optional[str].
+
+            - conversation_name: typing.Optional[str].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from athena.client import AsyncAthena
+
+        client = AsyncAthena()
+        await client.post_message(
+            content="content",
+        )
+        """
+        _request: typing.Dict[str, typing.Any] = {"content": content}
+        if model is not OMIT:
+            _request["model"] = model.value if model is not None else None
+        if tools is not OMIT:
+            _request["tools"] = tools
+        if conversation_id is not OMIT:
+            _request["conversation_id"] = conversation_id
+        if conversation_name is not OMIT:
+            _request["conversation_name"] = conversation_name
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            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
+            ),
+            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,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(MessageOut, _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_base_url(*, base_url: typing.Optional[str] = None, environment: AthenaEnvironment) -> str:
+    if base_url is not None:
+        return base_url
+    elif environment is not None:
+        return environment.value
+    else:
+        raise Exception("Please pass in either base_url or environment to construct the client")

athena_intelligence-0.1.5/src/athena/core/client_wrapper.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import httpx
+
+
+class BaseClientWrapper:
+    def __init__(self, *, base_url: str):
+        self._base_url = base_url
+
+    def get_headers(self) -> typing.Dict[str, str]:
+        headers: typing.Dict[str, str] = {
+            "X-Fern-Language": "Python",
+            "X-Fern-SDK-Name": "athena-intelligence",
+            "X-Fern-SDK-Version": "0.1.5",
+        }
+        return headers
+
+    def get_base_url(self) -> str:
+        return self._base_url
+
+
+class SyncClientWrapper(BaseClientWrapper):
+    def __init__(self, *, base_url: str, httpx_client: httpx.Client):
+        super().__init__(base_url=base_url)
+        self.httpx_client = httpx_client
+
+
+class AsyncClientWrapper(BaseClientWrapper):
+    def __init__(self, *, base_url: str, httpx_client: httpx.AsyncClient):
+        super().__init__(base_url=base_url)
+        self.httpx_client = httpx_client

{athena_intelligence-0.1.4 → athena_intelligence-0.1.5}/src/athena/environment.py

@@ -4,4 +4,4 @@ import enum
 
 
 class AthenaEnvironment(enum.Enum):
-    PRODUCTION = "https://api.athenaintelligence.ai"
+    DEFAULT = "https://api.athenaintelligence.ai"

athena_intelligence-0.1.5/src/athena/types/__init__.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .http_validation_error import HttpValidationError
+from .message_out import MessageOut
+from .message_out_dto import MessageOutDto
+from .model import Model
+from .tools import Tools
+from .validation_error import ValidationError
+from .validation_error_loc_item import ValidationErrorLocItem
+
+__all__ = [
+    "HttpValidationError",
+    "MessageOut",
+    "MessageOutDto",
+    "Model",
+    "Tools",
+    "ValidationError",
+    "ValidationErrorLocItem",
+]

{athena_intelligence-0.1.4 → athena_intelligence-0.1.5}/src/athena/types/http_validation_error.py

@@ -13,7 +13,7 @@ except ImportError:
 
 
 class HttpValidationError(pydantic.BaseModel):
-    detail: typing.List[ValidationError]
+    detail: typing.Optional[typing.List[ValidationError]] = None
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

athena_intelligence-0.1.5/src/athena/types/message_out.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 MessageOut(pydantic.BaseModel):
+    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
+        json_encoders = {dt.datetime: serialize_datetime}

athena_intelligence-0.1.5/src/athena/types/message_out_dto.py

@@ -0,0 +1,33 @@
+# 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 MessageOutDto(pydantic.BaseModel):
+    id: str
+    conversation_id: str
+    logs: typing.Optional[str] = None
+    content: typing.Optional[str] = None
+    created_at: str
+    status: 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
+        json_encoders = {dt.datetime: serialize_datetime}

athena_intelligence-0.1.5/src/athena/types/model.py

@@ -0,0 +1,29 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class Model(str, enum.Enum):
+    """
+    An enumeration.
+    """
+
+    GPT_4 = "gpt_4"
+    GPT_4_TURBO_PREVIEW = "gpt_4_turbo_preview"
+    GPT_3_5_TURBO = "gpt_3_5_turbo"
+
+    def visit(
+        self,
+        gpt_4: typing.Callable[[], T_Result],
+        gpt_4_turbo_preview: typing.Callable[[], T_Result],
+        gpt_3_5_turbo: typing.Callable[[], T_Result],
+    ) -> T_Result:
+        if self is Model.GPT_4:
+            return gpt_4()
+        if self is Model.GPT_4_TURBO_PREVIEW:
+            return gpt_4_turbo_preview()
+        if self is Model.GPT_3_5_TURBO:
+            return gpt_3_5_turbo()

athena_intelligence-0.1.5/src/athena/types/tools.py

@@ -0,0 +1,45 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class Tools(str, enum.Enum):
+    """
+    An enumeration.
+    """
+
+    SEARCH = "search"
+    BROWSE = "browse"
+    DATABASE_METADATA = "database_metadata"
+    QUERY = "query"
+    CHART = "chart"
+    ENRICH_PERSON = "enrich_person"
+    ENRICH_COMPANY = "enrich_company"
+
+    def visit(
+        self,
+        search: typing.Callable[[], T_Result],
+        browse: typing.Callable[[], T_Result],
+        database_metadata: typing.Callable[[], T_Result],
+        query: typing.Callable[[], T_Result],
+        chart: typing.Callable[[], T_Result],
+        enrich_person: typing.Callable[[], T_Result],
+        enrich_company: typing.Callable[[], T_Result],
+    ) -> T_Result:
+        if self is Tools.SEARCH:
+            return search()
+        if self is Tools.BROWSE:
+            return browse()
+        if self is Tools.DATABASE_METADATA:
+            return database_metadata()
+        if self is Tools.QUERY:
+            return query()
+        if self is Tools.CHART:
+            return chart()
+        if self is Tools.ENRICH_PERSON:
+            return enrich_person()
+        if self is Tools.ENRICH_COMPANY:
+            return enrich_company()

{athena_intelligence-0.1.4 → athena_intelligence-0.1.5}/src/athena/types/validation_error.py

@@ -4,6 +4,7 @@ import datetime as dt
 import typing
 
 from ..core.datetime_utils import serialize_datetime
+from .validation_error_loc_item import ValidationErrorLocItem
 
 try:
     import pydantic.v1 as pydantic  # type: ignore
@@ -12,9 +13,9 @@ except ImportError:
 
 
 class ValidationError(pydantic.BaseModel):
-    loc: typing.Optional[typing.List[str]] = None
-    msg: typing.Optional[str] = None
-    type: typing.Optional[str] = None
+    loc: typing.List[ValidationErrorLocItem]
+    msg: str
+    type: str
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}

athena_intelligence-0.1.4/src/athena/resources/__init__.py → athena_intelligence-0.1.5/src/athena/types/validation_error_loc_item.py

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

athena_intelligence-0.1.4/src/athena/__init__.py

@@ -1,8 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from .types import HttpValidationError, ValidationError
-from .errors import UnprocessableEntityError
-from .resources import message
-from .environment import AthenaEnvironment
-
-__all__ = ["AthenaEnvironment", "HttpValidationError", "UnprocessableEntityError", "ValidationError", "message"]

athena_intelligence-0.1.4/src/athena/client.py

@@ -1,100 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-import typing
-
-import httpx
-
-from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
-from .environment import AthenaEnvironment
-from .resources.message.client import AsyncMessageClient, MessageClient
-
-
-class Athena:
-    """
-    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propogate to these functions.
-
-    Parameters:
-        - base_url: typing.Optional[str]. The base url to use for requests from the client.
-
-        - environment: AthenaEnvironment. The environment to use for requests from the client. from .environment import AthenaEnvironment
-
-                                          Defaults to AthenaEnvironment.PRODUCTION
-
-        - token: typing.Union[str, typing.Callable[[], str]].
-
-        - timeout: typing.Optional[float]. The timeout to be used, in seconds, for requests by default the timeout is 60 seconds.
-
-        - httpx_client: typing.Optional[httpx.Client]. The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
-    ---
-    from athena.client import Athena
-
-    client = Athena(
-        token="YOUR_TOKEN",
-    )
-    """
-
-    def __init__(
-        self,
-        *,
-        base_url: typing.Optional[str] = None,
-        environment: AthenaEnvironment = AthenaEnvironment.PRODUCTION,
-        token: typing.Union[str, typing.Callable[[], str]],
-        timeout: typing.Optional[float] = 60,
-        httpx_client: typing.Optional[httpx.Client] = None
-    ):
-        self._client_wrapper = SyncClientWrapper(
-            base_url=_get_base_url(base_url=base_url, environment=environment),
-            token=token,
-            httpx_client=httpx.Client(timeout=timeout) if httpx_client is None else httpx_client,
-        )
-        self.message = MessageClient(client_wrapper=self._client_wrapper)
-
-
-class AsyncAthena:
-    """
-    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propogate to these functions.
-
-    Parameters:
-        - base_url: typing.Optional[str]. The base url to use for requests from the client.
-
-        - environment: AthenaEnvironment. The environment to use for requests from the client. from .environment import AthenaEnvironment
-
-                                          Defaults to AthenaEnvironment.PRODUCTION
-
-        - token: typing.Union[str, typing.Callable[[], str]].
-
-        - timeout: typing.Optional[float]. The timeout to be used, in seconds, for requests by default the timeout is 60 seconds.
-
-        - httpx_client: typing.Optional[httpx.AsyncClient]. The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
-    ---
-    from athena.client import AsyncAthena
-
-    client = AsyncAthena(
-        token="YOUR_TOKEN",
-    )
-    """
-
-    def __init__(
-        self,
-        *,
-        base_url: typing.Optional[str] = None,
-        environment: AthenaEnvironment = AthenaEnvironment.PRODUCTION,
-        token: typing.Union[str, typing.Callable[[], str]],
-        timeout: typing.Optional[float] = 60,
-        httpx_client: typing.Optional[httpx.AsyncClient] = None
-    ):
-        self._client_wrapper = AsyncClientWrapper(
-            base_url=_get_base_url(base_url=base_url, environment=environment),
-            token=token,
-            httpx_client=httpx.AsyncClient(timeout=timeout) if httpx_client is None else httpx_client,
-        )
-        self.message = AsyncMessageClient(client_wrapper=self._client_wrapper)
-
-
-def _get_base_url(*, base_url: typing.Optional[str] = None, environment: AthenaEnvironment) -> str:
-    if base_url is not None:
-        return base_url
-    elif environment is not None:
-        return environment.value
-    else:
-        raise Exception("Please pass in either base_url or environment to construct the client")

athena_intelligence-0.1.4/src/athena/core/client_wrapper.py

@@ -1,45 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-import typing
-
-import httpx
-
-
-class BaseClientWrapper:
-    def __init__(self, *, token: typing.Union[str, typing.Callable[[], str]], base_url: str):
-        self._token = token
-        self._base_url = base_url
-
-    def get_headers(self) -> typing.Dict[str, str]:
-        headers: typing.Dict[str, str] = {
-            "X-Fern-Language": "Python",
-            "X-Fern-SDK-Name": "athena-intelligence",
-            "X-Fern-SDK-Version": "0.1.4",
-        }
-        headers["Authorization"] = f"Bearer {self._get_token()}"
-        return headers
-
-    def _get_token(self) -> str:
-        if isinstance(self._token, str):
-            return self._token
-        else:
-            return self._token()
-
-    def get_base_url(self) -> str:
-        return self._base_url
-
-
-class SyncClientWrapper(BaseClientWrapper):
-    def __init__(
-        self, *, token: typing.Union[str, typing.Callable[[], str]], base_url: str, httpx_client: httpx.Client
-    ):
-        super().__init__(token=token, base_url=base_url)
-        self.httpx_client = httpx_client
-
-
-class AsyncClientWrapper(BaseClientWrapper):
-    def __init__(
-        self, *, token: typing.Union[str, typing.Callable[[], str]], base_url: str, httpx_client: httpx.AsyncClient
-    ):
-        super().__init__(token=token, base_url=base_url)
-        self.httpx_client = httpx_client

athena_intelligence-0.1.4/src/athena/resources/message/__init__.py

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

athena_intelligence-0.1.4/src/athena/resources/message/client.py

@@ -1,329 +0,0 @@
-# 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
-
-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 MessageClient:
-    def __init__(self, *, client_wrapper: SyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    def get(self, *, message_id: str, request_options: typing.Optional[RequestOptions] = None) -> typing.Any:
-        """
-        Parameters:
-            - message_id: str. The ID of the message to retrieve
-
-            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
-        ---
-        from athena.client import Athena
-
-        client = Athena(
-            token="YOUR_TOKEN",
-        )
-        client.message.get(
-            message_id="message_id",
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/auth/athena-get-message"),
-            params=jsonable_encoder(
-                remove_none_from_dict(
-                    {
-                        "message_id": message_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 60,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _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 submit(
-        self,
-        *,
-        additional_context: typing.Optional[str] = OMIT,
-        config: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
-        content: str,
-        conversation_id: typing.Optional[str] = OMIT,
-        conversation_name: typing.Optional[str] = OMIT,
-        documents: typing.Optional[typing.Sequence[str]] = OMIT,
-        model: typing.Optional[str] = OMIT,
-        sdataset_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        tools: typing.Optional[typing.Sequence[str]] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> typing.Any:
-        """
-        Parameters:
-            - additional_context: typing.Optional[str].
-
-            - config: typing.Optional[typing.Dict[str, typing.Any]].
-
-            - content: str.
-
-            - conversation_id: typing.Optional[str].
-
-            - conversation_name: typing.Optional[str].
-
-            - documents: typing.Optional[typing.Sequence[str]].
-
-            - model: typing.Optional[str].
-
-            - sdataset_ids: typing.Optional[typing.Sequence[str]].
-
-            - tools: typing.Optional[typing.Sequence[str]].
-
-            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
-        ---
-        from athena.client import Athena
-
-        client = Athena(
-            token="YOUR_TOKEN",
-        )
-        client.message.submit(
-            content="content",
-        )
-        """
-        _request: typing.Dict[str, typing.Any] = {"content": content}
-        if additional_context is not OMIT:
-            _request["additional_context"] = additional_context
-        if config is not OMIT:
-            _request["config"] = config
-        if conversation_id is not OMIT:
-            _request["conversation_id"] = conversation_id
-        if conversation_name is not OMIT:
-            _request["conversation_name"] = conversation_name
-        if documents is not OMIT:
-            _request["documents"] = documents
-        if model is not OMIT:
-            _request["model"] = model
-        if sdataset_ids is not OMIT:
-            _request["sdataset_ids"] = sdataset_ids
-        if tools is not OMIT:
-            _request["tools"] = tools
-        _response = self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/auth/athena-submit-message"),
-            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,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _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 AsyncMessageClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    async def get(self, *, message_id: str, request_options: typing.Optional[RequestOptions] = None) -> typing.Any:
-        """
-        Parameters:
-            - message_id: str. The ID of the message to retrieve
-
-            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
-        ---
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            token="YOUR_TOKEN",
-        )
-        await client.message.get(
-            message_id="message_id",
-        )
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/auth/athena-get-message"),
-            params=jsonable_encoder(
-                remove_none_from_dict(
-                    {
-                        "message_id": message_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 60,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _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 submit(
-        self,
-        *,
-        additional_context: typing.Optional[str] = OMIT,
-        config: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
-        content: str,
-        conversation_id: typing.Optional[str] = OMIT,
-        conversation_name: typing.Optional[str] = OMIT,
-        documents: typing.Optional[typing.Sequence[str]] = OMIT,
-        model: typing.Optional[str] = OMIT,
-        sdataset_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        tools: typing.Optional[typing.Sequence[str]] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> typing.Any:
-        """
-        Parameters:
-            - additional_context: typing.Optional[str].
-
-            - config: typing.Optional[typing.Dict[str, typing.Any]].
-
-            - content: str.
-
-            - conversation_id: typing.Optional[str].
-
-            - conversation_name: typing.Optional[str].
-
-            - documents: typing.Optional[typing.Sequence[str]].
-
-            - model: typing.Optional[str].
-
-            - sdataset_ids: typing.Optional[typing.Sequence[str]].
-
-            - tools: typing.Optional[typing.Sequence[str]].
-
-            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
-        ---
-        from athena.client import AsyncAthena
-
-        client = AsyncAthena(
-            token="YOUR_TOKEN",
-        )
-        await client.message.submit(
-            content="content",
-        )
-        """
-        _request: typing.Dict[str, typing.Any] = {"content": content}
-        if additional_context is not OMIT:
-            _request["additional_context"] = additional_context
-        if config is not OMIT:
-            _request["config"] = config
-        if conversation_id is not OMIT:
-            _request["conversation_id"] = conversation_id
-        if conversation_name is not OMIT:
-            _request["conversation_name"] = conversation_name
-        if documents is not OMIT:
-            _request["documents"] = documents
-        if model is not OMIT:
-            _request["model"] = model
-        if sdataset_ids is not OMIT:
-            _request["sdataset_ids"] = sdataset_ids
-        if tools is not OMIT:
-            _request["tools"] = tools
-        _response = await self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/auth/athena-submit-message"),
-            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,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _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.4/src/athena/types/__init__.py

@@ -1,6 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from .http_validation_error import HttpValidationError
-from .validation_error import ValidationError
-
-__all__ = ["HttpValidationError", "ValidationError"]