athena-intelligence 0.1.1__tar.gz

athena_intelligence-0.1.1/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.1
+Name: athena-intelligence
+Version: 0.1.1
+Summary: 
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: httpx (>=0.21.2)
+Requires-Dist: pydantic (>=1.9.2)
+Requires-Dist: typing_extensions (>=4.0.0)
+Description-Content-Type: text/markdown
+
+# Athena Intelligence Python Library
+
+[![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-SDK%20generated%20by%20Fern-brightgreen)](https://github.com/fern-api/fern)
+[![pypi](https://img.shields.io/pypi/v/athena-intel.svg)](https://pypi.python.org/pypi/athena-intel)
+
+The Athena Intelligence Python Library provides convenient access to the Athena Intelligence API from 
+applications written in Python. 
+
+The library includes type definitions for all 
+request and response fields, and offers both synchronous and asynchronous clients powered by httpx.
+
+## Installation
+
+Add this dependency to your project's build file:
+
+```bash
+pip install athena-intel
+# or
+poetry add athena-intel
+```
+
+## Usage
+Simply import `Athena` and start making calls to our API. 
+
+```python
+from athena.client import Athena
+
+client = Athena(
+  api_key="YOUR_API_KEY" # Defaults to ATHENA_API_KEY
+)
+message = client.messages.get("message_id")
+```
+
+## Async Client
+The SDK also exports an async client so that you can make non-blocking
+calls to our API. 
+
+```python
+from athena.client import AsyncAthena
+
+client = AsyncAthena(
+  api_key="YOUR_API_KEY" # Defaults to ATHENA_API_KEY
+)
+
+async def main() -> None:
+    message = client.messages.get("message_id")
+    print("Received message", message)
+
+asyncio.run(main())
+```
+
+## Athena Module
+All of the models are nested within the Athena module. Let IntelliSense 
+guide you! 
+
+## Exception Handling
+All errors thrown by the SDK will be subclasses of [`ApiError`](./src/athena/core/api_error.py).
+
+```python
+import athena
+
+try:
+  client.messages.get(...)
+except athena.core.ApiError as e: # Handle all errors
+  print(e.status_code)
+  print(e.body)
+```
+
+## Advanced
+
+### Timeouts
+By default, requests time out after 60 seconds. You can configure this with a 
+timeout option at the client or request level.
+
+```python
+from athena.client import Athena
+
+client = Athena(
+    # All timeouts are 20 seconds
+    timeout=20.0,
+)
+
+# Override timeout for a specific method
+client.messages.get(..., {
+    timeout_in_seconds=20
+})
+```
+
+### Custom HTTP client
+You can override the httpx client to customize it for your use-case. Some common use-cases 
+include support for proxies and transports.
+
+```python
+import httpx
+
+from athena.client import Athena
+
+client = Athena(
+    http_client=httpx.Client(
+        proxies="http://my.test.proxy.example.com",
+        transport=httpx.HTTPTransport(local_address="0.0.0.0"),
+    ),
+)
+```
+
+## Beta Status
+
+This SDK is in **Preview**, and there may be breaking changes between versions without a major 
+version update. 
+
+To ensure a reproducible environment (and minimize risk of breaking changes), we recommend pinning a specific package version.
+
+## Contributing
+
+While we value open-source contributions to this SDK, this library is generated programmatically. 
+Additions made directly to this library would have to be moved over to our generation code, 
+otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
+ a proof of concept, but know that we will not be able to merge it as-is. We suggest opening 
+an issue first to discuss with us!
+
+On the other hand, contributions to the README are always very welcome!
+

athena_intelligence-0.1.1/README.md

@@ -0,0 +1,121 @@
+# Athena Intelligence Python Library
+
+[![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-SDK%20generated%20by%20Fern-brightgreen)](https://github.com/fern-api/fern)
+[![pypi](https://img.shields.io/pypi/v/athena-intel.svg)](https://pypi.python.org/pypi/athena-intel)
+
+The Athena Intelligence Python Library provides convenient access to the Athena Intelligence API from 
+applications written in Python. 
+
+The library includes type definitions for all 
+request and response fields, and offers both synchronous and asynchronous clients powered by httpx.
+
+## Installation
+
+Add this dependency to your project's build file:
+
+```bash
+pip install athena-intel
+# or
+poetry add athena-intel
+```
+
+## Usage
+Simply import `Athena` and start making calls to our API. 
+
+```python
+from athena.client import Athena
+
+client = Athena(
+  api_key="YOUR_API_KEY" # Defaults to ATHENA_API_KEY
+)
+message = client.messages.get("message_id")
+```
+
+## Async Client
+The SDK also exports an async client so that you can make non-blocking
+calls to our API. 
+
+```python
+from athena.client import AsyncAthena
+
+client = AsyncAthena(
+  api_key="YOUR_API_KEY" # Defaults to ATHENA_API_KEY
+)
+
+async def main() -> None:
+    message = client.messages.get("message_id")
+    print("Received message", message)
+
+asyncio.run(main())
+```
+
+## Athena Module
+All of the models are nested within the Athena module. Let IntelliSense 
+guide you! 
+
+## Exception Handling
+All errors thrown by the SDK will be subclasses of [`ApiError`](./src/athena/core/api_error.py).
+
+```python
+import athena
+
+try:
+  client.messages.get(...)
+except athena.core.ApiError as e: # Handle all errors
+  print(e.status_code)
+  print(e.body)
+```
+
+## Advanced
+
+### Timeouts
+By default, requests time out after 60 seconds. You can configure this with a 
+timeout option at the client or request level.
+
+```python
+from athena.client import Athena
+
+client = Athena(
+    # All timeouts are 20 seconds
+    timeout=20.0,
+)
+
+# Override timeout for a specific method
+client.messages.get(..., {
+    timeout_in_seconds=20
+})
+```
+
+### Custom HTTP client
+You can override the httpx client to customize it for your use-case. Some common use-cases 
+include support for proxies and transports.
+
+```python
+import httpx
+
+from athena.client import Athena
+
+client = Athena(
+    http_client=httpx.Client(
+        proxies="http://my.test.proxy.example.com",
+        transport=httpx.HTTPTransport(local_address="0.0.0.0"),
+    ),
+)
+```
+
+## Beta Status
+
+This SDK is in **Preview**, and there may be breaking changes between versions without a major 
+version update. 
+
+To ensure a reproducible environment (and minimize risk of breaking changes), we recommend pinning a specific package version.
+
+## Contributing
+
+While we value open-source contributions to this SDK, this library is generated programmatically. 
+Additions made directly to this library would have to be moved over to our generation code, 
+otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
+ a proof of concept, but know that we will not be able to merge it as-is. We suggest opening 
+an issue first to discuss with us!
+
+On the other hand, contributions to the README are always very welcome!

athena_intelligence-0.1.1/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "athena-intelligence"
+version = "0.1.1"
+description = ""
+readme = "README.md"
+authors = []
+packages = [
+    { include = "athena", from = "src"}
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+httpx = ">=0.21.2"
+pydantic = ">= 1.9.2"
+typing_extensions = ">= 4.0.0"
+
+[tool.poetry.dev-dependencies]
+mypy = "^1.8.0"
+pytest = "^7.4.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

athena_intelligence-0.1.1/src/athena/__init__.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .resources import Message, message
+from .environment import AthenaEnvironment
+
+__all__ = ["AthenaEnvironment", "Message", "message"]

athena_intelligence-0.1.1/src/athena/client.py

@@ -0,0 +1,110 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import os
+import typing
+
+import httpx
+
+from .core.api_error import ApiError
+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
+
+        - api_key: typing.Optional[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(
+        api_key="YOUR_API_KEY",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: AthenaEnvironment = AthenaEnvironment.PRODUCTION,
+        api_key: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = os.getenv("ATHENA_API_KEY"),
+        timeout: typing.Optional[float] = 60,
+        httpx_client: typing.Optional[httpx.Client] = None
+    ):
+        if api_key is None:
+            raise ApiError(
+                body="The client must be instantiated be either passing in api_key or setting ATHENA_API_KEY"
+            )
+        self._client_wrapper = SyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            api_key=api_key,
+            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
+
+        - api_key: typing.Optional[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(
+        api_key="YOUR_API_KEY",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: AthenaEnvironment = AthenaEnvironment.PRODUCTION,
+        api_key: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = os.getenv("ATHENA_API_KEY"),
+        timeout: typing.Optional[float] = 60,
+        httpx_client: typing.Optional[httpx.AsyncClient] = None
+    ):
+        if api_key is None:
+            raise ApiError(
+                body="The client must be instantiated be either passing in api_key or setting ATHENA_API_KEY"
+            )
+        self._client_wrapper = AsyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            api_key=api_key,
+            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.1/src/athena/core/__init__.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .api_error import ApiError
+from .client_wrapper import AsyncClientWrapper, BaseClientWrapper, SyncClientWrapper
+from .datetime_utils import serialize_datetime
+from .file import File, convert_file_dict_to_httpx_tuples
+from .jsonable_encoder import jsonable_encoder
+from .remove_none_from_dict import remove_none_from_dict
+from .request_options import RequestOptions
+
+__all__ = [
+    "ApiError",
+    "AsyncClientWrapper",
+    "BaseClientWrapper",
+    "File",
+    "RequestOptions",
+    "SyncClientWrapper",
+    "convert_file_dict_to_httpx_tuples",
+    "jsonable_encoder",
+    "remove_none_from_dict",
+    "serialize_datetime",
+]

athena_intelligence-0.1.1/src/athena/core/api_error.py

@@ -0,0 +1,15 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+
+class ApiError(Exception):
+    status_code: typing.Optional[int]
+    body: typing.Any
+
+    def __init__(self, *, status_code: typing.Optional[int] = None, body: typing.Any = None):
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"status_code: {self.status_code}, body: {self.body}"

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

@@ -0,0 +1,45 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import httpx
+
+
+class BaseClientWrapper:
+    def __init__(self, *, api_key: typing.Union[str, typing.Callable[[], str]], base_url: str):
+        self._api_key = api_key
+        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.1",
+        }
+        headers["Authorization"] = f"Bearer {self._get_api_key()}"
+        return headers
+
+    def _get_api_key(self) -> str:
+        if isinstance(self._api_key, str):
+            return self._api_key
+        else:
+            return self._api_key()
+
+    def get_base_url(self) -> str:
+        return self._base_url
+
+
+class SyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self, *, api_key: typing.Union[str, typing.Callable[[], str]], base_url: str, httpx_client: httpx.Client
+    ):
+        super().__init__(api_key=api_key, base_url=base_url)
+        self.httpx_client = httpx_client
+
+
+class AsyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self, *, api_key: typing.Union[str, typing.Callable[[], str]], base_url: str, httpx_client: httpx.AsyncClient
+    ):
+        super().__init__(api_key=api_key, base_url=base_url)
+        self.httpx_client = httpx_client

athena_intelligence-0.1.1/src/athena/core/datetime_utils.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+
+
+def serialize_datetime(v: dt.datetime) -> str:
+    """
+    Serialize a datetime including timezone info.
+
+    Uses the timezone info provided if present, otherwise uses the current runtime's timezone info.
+
+    UTC datetimes end in "Z" while all other timezones are represented as offset from UTC, e.g. +05:00.
+    """
+
+    def _serialize_zoned_datetime(v: dt.datetime) -> str:
+        if v.tzinfo is not None and v.tzinfo.tzname(None) == dt.timezone.utc.tzname(None):
+            # UTC is a special case where we use "Z" at the end instead of "+00:00"
+            return v.isoformat().replace("+00:00", "Z")
+        else:
+            # Delegate to the typical +/- offset format
+            return v.isoformat()
+
+    if v.tzinfo is not None:
+        return _serialize_zoned_datetime(v)
+    else:
+        local_tz = dt.datetime.now().astimezone().tzinfo
+        localized_dt = v.replace(tzinfo=local_tz)
+        return _serialize_zoned_datetime(localized_dt)

athena_intelligence-0.1.1/src/athena/core/file.py

@@ -0,0 +1,38 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+# File typing inspired by the flexibility of types within the httpx library
+# https://github.com/encode/httpx/blob/master/httpx/_types.py
+FileContent = typing.Union[typing.IO[bytes], bytes, str]
+File = typing.Union[
+    # file (or bytes)
+    FileContent,
+    # (filename, file (or bytes))
+    typing.Tuple[typing.Optional[str], FileContent],
+    # (filename, file (or bytes), content_type)
+    typing.Tuple[typing.Optional[str], FileContent, typing.Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    typing.Tuple[typing.Optional[str], FileContent, typing.Optional[str], typing.Mapping[str, str]],
+]
+
+
+def convert_file_dict_to_httpx_tuples(
+    d: typing.Dict[str, typing.Union[File, typing.List[File]]]
+) -> typing.List[typing.Tuple[str, File]]:
+    """
+    The format we use is a list of tuples, where the first element is the
+    name of the file and the second is the file object. Typically HTTPX wants
+    a dict, but to be able to send lists of files, you have to use the list
+    approach (which also works for non-lists)
+    https://github.com/encode/httpx/pull/1032
+    """
+
+    httpx_tuples = []
+    for key, file_like in d.items():
+        if isinstance(file_like, list):
+            for file_like_item in file_like:
+                httpx_tuples.append((key, file_like_item))
+        else:
+            httpx_tuples.append((key, file_like))
+    return httpx_tuples

athena_intelligence-0.1.1/src/athena/core/jsonable_encoder.py

@@ -0,0 +1,103 @@
+# This file was auto-generated by Fern from our API Definition.
+
+"""
+jsonable_encoder converts a Python object to a JSON-friendly dict
+(e.g. datetimes to strings, Pydantic models to dicts).
+
+Taken from FastAPI, and made a bit simpler
+https://github.com/tiangolo/fastapi/blob/master/fastapi/encoders.py
+"""
+
+import dataclasses
+import datetime as dt
+from collections import defaultdict
+from enum import Enum
+from pathlib import PurePath
+from types import GeneratorType
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+from .datetime_utils import serialize_datetime
+
+SetIntStr = Set[Union[int, str]]
+DictIntStrAny = Dict[Union[int, str], Any]
+
+
+def generate_encoders_by_class_tuples(
+    type_encoder_map: Dict[Any, Callable[[Any], Any]]
+) -> Dict[Callable[[Any], Any], Tuple[Any, ...]]:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(tuple)
+    for type_, encoder in type_encoder_map.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+    return encoders_by_class_tuples
+
+
+encoders_by_class_tuples = generate_encoders_by_class_tuples(pydantic.json.ENCODERS_BY_TYPE)
+
+
+def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None) -> Any:
+    custom_encoder = custom_encoder or {}
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if isinstance(obj, pydantic.BaseModel):
+        encoder = getattr(obj.__config__, "json_encoders", {})
+        if custom_encoder:
+            encoder.update(custom_encoder)
+        obj_dict = obj.dict(by_alias=True)
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        return jsonable_encoder(obj_dict, custom_encoder=encoder)
+    if dataclasses.is_dataclass(obj):
+        obj_dict = dataclasses.asdict(obj)
+        return jsonable_encoder(obj_dict, custom_encoder=custom_encoder)
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, dt.date):
+        return str(obj)
+    if isinstance(obj, dt.datetime):
+        return serialize_datetime(obj)
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        allowed_keys = set(obj.keys())
+        for key, value in obj.items():
+            if key in allowed_keys:
+                encoded_key = jsonable_encoder(key, custom_encoder=custom_encoder)
+                encoded_value = jsonable_encoder(value, custom_encoder=custom_encoder)
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple)):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(jsonable_encoder(item, custom_encoder=custom_encoder))
+        return encoded_list
+
+    if type(obj) in pydantic.json.ENCODERS_BY_TYPE:
+        return pydantic.json.ENCODERS_BY_TYPE[type(obj)](obj)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+
+    try:
+        data = dict(obj)
+    except Exception as e:
+        errors: List[Exception] = []
+        errors.append(e)
+        try:
+            data = vars(obj)
+        except Exception as e:
+            errors.append(e)
+            raise ValueError(errors) from e
+    return jsonable_encoder(data, custom_encoder=custom_encoder)

athena_intelligence-0.1.1/src/athena/core/remove_none_from_dict.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Any, Dict, Optional
+
+
+def remove_none_from_dict(original: Dict[str, Optional[Any]]) -> Dict[str, Any]:
+    new: Dict[str, Any] = {}
+    for key, value in original.items():
+        if value is not None:
+            new[key] = value
+    return new

athena_intelligence-0.1.1/src/athena/core/request_options.py

@@ -0,0 +1,29 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+try:
+    from typing import NotRequired  # type: ignore
+except ImportError:
+    from typing_extensions import NotRequired  # type: ignore
+
+
+class RequestOptions(typing.TypedDict):
+    """
+    Additional options for request-specific configuration when calling APIs via the SDK.
+    This is used primarily as an optional final parameter for service functions.
+
+    Attributes:
+        - timeout_in_seconds: int. The number of seconds to await an API call before timing out.
+
+        - additional_headers: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's header dict
+
+        - additional_query_parameters: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's query parameters dict
+
+        - additional_body_parameters: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's body parameters dict
+    """
+
+    timeout_in_seconds: NotRequired[int]
+    additional_headers: NotRequired[typing.Dict[str, typing.Any]]
+    additional_query_parameters: NotRequired[typing.Dict[str, typing.Any]]
+    additional_body_parameters: NotRequired[typing.Dict[str, typing.Any]]

athena_intelligence-0.1.1/src/athena/environment.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+
+
+class AthenaEnvironment(enum.Enum):
+    PRODUCTION = "app.athenaintelligence.ai"

athena_intelligence-0.1.1/src/athena/resources/__init__.py

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

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

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

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

@@ -0,0 +1,292 @@
+# 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 .types.message import Message
+
+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: typing.Optional[str], *, request_options: typing.Optional[RequestOptions] = None
+    ) -> Message:
+        """
+        Get an Athena message by ID.
+        Returns an Athena message final output.
+
+        Parameters:
+            - message_id: typing.Optional[str].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", f"api/v0/athena/agent/{jsonable_encoder(message_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(Message, _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 send(
+        self,
+        *,
+        content: str,
+        conversation_id: typing.Optional[str] = OMIT,
+        user_id: typing.Optional[str] = OMIT,
+        workspace_id: typing.Optional[str] = OMIT,
+        sdataset_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        tools: typing.Optional[typing.Sequence[str]] = OMIT,
+        model: typing.Optional[str] = OMIT,
+        documents: typing.Optional[typing.Sequence[str]] = OMIT,
+        config: typing.Dict[str, typing.Any],
+        additional_context: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> Message:
+        """
+        Send a message to Athena.
+        Returns an Athena message with ID, content and final output.
+
+        Parameters:
+            - content: str.
+
+            - conversation_id: typing.Optional[str].
+
+            - user_id: typing.Optional[str].
+
+            - workspace_id: typing.Optional[str].
+
+            - sdataset_ids: typing.Optional[typing.Sequence[str]].
+
+            - tools: typing.Optional[typing.Sequence[str]].
+
+            - model: typing.Optional[str].
+
+            - documents: typing.Optional[typing.Sequence[str]].
+
+            - config: typing.Dict[str, typing.Any].
+
+            - additional_context: typing.Optional[str].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        """
+        _request: typing.Dict[str, typing.Any] = {"content": content, "config": config}
+        if conversation_id is not OMIT:
+            _request["conversation_id"] = conversation_id
+        if user_id is not OMIT:
+            _request["user_id"] = user_id
+        if workspace_id is not OMIT:
+            _request["workspace_id"] = workspace_id
+        if sdataset_ids is not OMIT:
+            _request["sdataset_ids"] = sdataset_ids
+        if tools is not OMIT:
+            _request["tools"] = tools
+        if model is not OMIT:
+            _request["model"] = model
+        if documents is not OMIT:
+            _request["documents"] = documents
+        if additional_context is not OMIT:
+            _request["additional_context"] = additional_context
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/athena/agent"),
+            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(Message, _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: typing.Optional[str], *, request_options: typing.Optional[RequestOptions] = None
+    ) -> Message:
+        """
+        Get an Athena message by ID.
+        Returns an Athena message final output.
+
+        Parameters:
+            - message_id: typing.Optional[str].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", f"api/v0/athena/agent/{jsonable_encoder(message_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(Message, _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 send(
+        self,
+        *,
+        content: str,
+        conversation_id: typing.Optional[str] = OMIT,
+        user_id: typing.Optional[str] = OMIT,
+        workspace_id: typing.Optional[str] = OMIT,
+        sdataset_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        tools: typing.Optional[typing.Sequence[str]] = OMIT,
+        model: typing.Optional[str] = OMIT,
+        documents: typing.Optional[typing.Sequence[str]] = OMIT,
+        config: typing.Dict[str, typing.Any],
+        additional_context: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> Message:
+        """
+        Send a message to Athena.
+        Returns an Athena message with ID, content and final output.
+
+        Parameters:
+            - content: str.
+
+            - conversation_id: typing.Optional[str].
+
+            - user_id: typing.Optional[str].
+
+            - workspace_id: typing.Optional[str].
+
+            - sdataset_ids: typing.Optional[typing.Sequence[str]].
+
+            - tools: typing.Optional[typing.Sequence[str]].
+
+            - model: typing.Optional[str].
+
+            - documents: typing.Optional[typing.Sequence[str]].
+
+            - config: typing.Dict[str, typing.Any].
+
+            - additional_context: typing.Optional[str].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        """
+        _request: typing.Dict[str, typing.Any] = {"content": content, "config": config}
+        if conversation_id is not OMIT:
+            _request["conversation_id"] = conversation_id
+        if user_id is not OMIT:
+            _request["user_id"] = user_id
+        if workspace_id is not OMIT:
+            _request["workspace_id"] = workspace_id
+        if sdataset_ids is not OMIT:
+            _request["sdataset_ids"] = sdataset_ids
+        if tools is not OMIT:
+            _request["tools"] = tools
+        if model is not OMIT:
+            _request["model"] = model
+        if documents is not OMIT:
+            _request["documents"] = documents
+        if additional_context is not OMIT:
+            _request["additional_context"] = additional_context
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "api/v0/athena/agent"),
+            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(Message, _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.1/src/athena/resources/message/types/__init__.py

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

athena_intelligence-0.1.1/src/athena/resources/message/types/message.py

@@ -0,0 +1,35 @@
+# 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 Message(pydantic.BaseModel):
+    message_id: str
+    conversation_id: str
+    sender: str
+    content: str
+    status: str
+    created_at: dt.datetime
+    config: typing.Dict[str, typing.Any]
+    final_output: 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}