athena-intelligence 0.1.230__py3-none-any.whl → 0.1.242__py3-none-any.whl

athena/base_client.py

@@ -1,16 +1,20 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from __future__ import annotations
+
 import typing
 
 import httpx
-from .agents.client import AgentsClient, AsyncAgentsClient
-from .aop.client import AopClient, AsyncAopClient
-from .assets.client import AssetsClient, AsyncAssetsClient
 from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from .environment import AthenaEnvironment
-from .query.client import AsyncQueryClient, QueryClient
-from .threads.client import AsyncThreadsClient, ThreadsClient
-from .tools.client import AsyncToolsClient, ToolsClient
+
+if typing.TYPE_CHECKING:
+    from .agents.client import AgentsClient, AsyncAgentsClient
+    from .aop.client import AopClient, AsyncAopClient
+    from .assets.client import AssetsClient, AsyncAssetsClient
+    from .query.client import AsyncQueryClient, QueryClient
+    from .threads.client import AsyncThreadsClient, ThreadsClient
+    from .tools.client import AsyncToolsClient, ToolsClient
 
 
 class BaseAthena:
@@ -78,12 +82,60 @@ class BaseAthena:
             else httpx.Client(timeout=_defaulted_timeout),
             timeout=_defaulted_timeout,
         )
-        self.agents = AgentsClient(client_wrapper=self._client_wrapper)
-        self.aop = AopClient(client_wrapper=self._client_wrapper)
-        self.assets = AssetsClient(client_wrapper=self._client_wrapper)
-        self.query = QueryClient(client_wrapper=self._client_wrapper)
-        self.threads = ThreadsClient(client_wrapper=self._client_wrapper)
-        self.tools = ToolsClient(client_wrapper=self._client_wrapper)
+        self._agents: typing.Optional[AgentsClient] = None
+        self._aop: typing.Optional[AopClient] = None
+        self._assets: typing.Optional[AssetsClient] = None
+        self._query: typing.Optional[QueryClient] = None
+        self._threads: typing.Optional[ThreadsClient] = None
+        self._tools: typing.Optional[ToolsClient] = None
+
+    @property
+    def agents(self):
+        if self._agents is None:
+            from .agents.client import AgentsClient  # noqa: E402
+
+            self._agents = AgentsClient(client_wrapper=self._client_wrapper)
+        return self._agents
+
+    @property
+    def aop(self):
+        if self._aop is None:
+            from .aop.client import AopClient  # noqa: E402
+
+            self._aop = AopClient(client_wrapper=self._client_wrapper)
+        return self._aop
+
+    @property
+    def assets(self):
+        if self._assets is None:
+            from .assets.client import AssetsClient  # noqa: E402
+
+            self._assets = AssetsClient(client_wrapper=self._client_wrapper)
+        return self._assets
+
+    @property
+    def query(self):
+        if self._query is None:
+            from .query.client import QueryClient  # noqa: E402
+
+            self._query = QueryClient(client_wrapper=self._client_wrapper)
+        return self._query
+
+    @property
+    def threads(self):
+        if self._threads is None:
+            from .threads.client import ThreadsClient  # noqa: E402
+
+            self._threads = ThreadsClient(client_wrapper=self._client_wrapper)
+        return self._threads
+
+    @property
+    def tools(self):
+        if self._tools is None:
+            from .tools.client import ToolsClient  # noqa: E402
+
+            self._tools = ToolsClient(client_wrapper=self._client_wrapper)
+        return self._tools
 
 
 class AsyncBaseAthena:
@@ -151,12 +203,60 @@ class AsyncBaseAthena:
             else httpx.AsyncClient(timeout=_defaulted_timeout),
             timeout=_defaulted_timeout,
         )
-        self.agents = AsyncAgentsClient(client_wrapper=self._client_wrapper)
-        self.aop = AsyncAopClient(client_wrapper=self._client_wrapper)
-        self.assets = AsyncAssetsClient(client_wrapper=self._client_wrapper)
-        self.query = AsyncQueryClient(client_wrapper=self._client_wrapper)
-        self.threads = AsyncThreadsClient(client_wrapper=self._client_wrapper)
-        self.tools = AsyncToolsClient(client_wrapper=self._client_wrapper)
+        self._agents: typing.Optional[AsyncAgentsClient] = None
+        self._aop: typing.Optional[AsyncAopClient] = None
+        self._assets: typing.Optional[AsyncAssetsClient] = None
+        self._query: typing.Optional[AsyncQueryClient] = None
+        self._threads: typing.Optional[AsyncThreadsClient] = None
+        self._tools: typing.Optional[AsyncToolsClient] = None
+
+    @property
+    def agents(self):
+        if self._agents is None:
+            from .agents.client import AsyncAgentsClient  # noqa: E402
+
+            self._agents = AsyncAgentsClient(client_wrapper=self._client_wrapper)
+        return self._agents
+
+    @property
+    def aop(self):
+        if self._aop is None:
+            from .aop.client import AsyncAopClient  # noqa: E402
+
+            self._aop = AsyncAopClient(client_wrapper=self._client_wrapper)
+        return self._aop
+
+    @property
+    def assets(self):
+        if self._assets is None:
+            from .assets.client import AsyncAssetsClient  # noqa: E402
+
+            self._assets = AsyncAssetsClient(client_wrapper=self._client_wrapper)
+        return self._assets
+
+    @property
+    def query(self):
+        if self._query is None:
+            from .query.client import AsyncQueryClient  # noqa: E402
+
+            self._query = AsyncQueryClient(client_wrapper=self._client_wrapper)
+        return self._query
+
+    @property
+    def threads(self):
+        if self._threads is None:
+            from .threads.client import AsyncThreadsClient  # noqa: E402
+
+            self._threads = AsyncThreadsClient(client_wrapper=self._client_wrapper)
+        return self._threads
+
+    @property
+    def tools(self):
+        if self._tools is None:
+            from .tools.client import AsyncToolsClient  # noqa: E402
+
+            self._tools = AsyncToolsClient(client_wrapper=self._client_wrapper)
+        return self._tools
 
 
 def _get_base_url(*, base_url: typing.Optional[str] = None, environment: AthenaEnvironment) -> str:

athena/client.py

@@ -449,8 +449,6 @@ class Athena(BaseAthena):
     )
     """
 
-    tools: WrappedToolsClient
-
     def __init__(
         self,
         *,
@@ -484,12 +482,17 @@ class Athena(BaseAthena):
             timeout=timeout,
             httpx_client=httpx_client,
         )
-        self.tools = WrappedToolsClient(client_wrapper=self._client_wrapper)
-        self.query = WrappedQueryClient(client_wrapper=self._client_wrapper)
+        self._tools: typing.Optional[WrappedToolsClient] = None
         self.llm = AthenaModel(
             base_url=base_url or environment.value, api_key=api_key, timeout=timeout
         )
 
+    @property
+    def tools(self) -> WrappedToolsClient:
+        if self._tools is None:
+            self._tools = WrappedToolsClient(client_wrapper=self._client_wrapper)
+        return self._tools
+
 
 class AsyncAthena(AsyncBaseAthena):
     """
@@ -522,8 +525,6 @@ class AsyncAthena(AsyncBaseAthena):
     )
     """
 
-    tools: WrappedAsyncToolsClient
-
     def __init__(
         self,
         *,
@@ -550,6 +551,7 @@ class AsyncAthena(AsyncBaseAthena):
                 environment = cast(AthenaEnvironment, AutodetectedEnvironments.CURRENT)
             else:
                 environment = AthenaEnvironment.PRODUCTION
+        self._tools: typing.Optional[WrappedAsyncToolsClient] = None
         super().__init__(
             base_url=base_url,
             environment=environment,  # type: ignore[arg-type]
@@ -557,8 +559,12 @@ class AsyncAthena(AsyncBaseAthena):
             timeout=timeout,
             httpx_client=httpx_client,
         )
-        self.tools = WrappedAsyncToolsClient(client_wrapper=self._client_wrapper)
-        self.query = WrappedAsyncQueryClient(client_wrapper=self._client_wrapper)
+
+    @property
+    def tools(self) -> WrappedAsyncToolsClient:
+        if self._tools is None:
+            self._tools = WrappedAsyncToolsClient(client_wrapper=self._client_wrapper)
+        return self._tools
 
 
 def _read_json_frame(model: DataFrameRequestOut) -> "pd.DataFrame":

athena/core/__init__.py

@@ -2,26 +2,79 @@
 
 # isort: skip_file
 
-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, with_content_type
-from .http_client import AsyncHttpClient, HttpClient
-from .http_response import AsyncHttpResponse, HttpResponse
-from .jsonable_encoder import jsonable_encoder
-from .pydantic_utilities import (
-    IS_PYDANTIC_V2,
-    UniversalBaseModel,
-    UniversalRootModel,
-    parse_obj_as,
-    universal_field_validator,
-    universal_root_validator,
-    update_forward_refs,
-)
-from .query_encoder import encode_query
-from .remove_none_from_dict import remove_none_from_dict
-from .request_options import RequestOptions
-from .serialization import FieldMetadata, convert_and_respect_annotation_metadata
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    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, with_content_type
+    from .http_client import AsyncHttpClient, HttpClient
+    from .http_response import AsyncHttpResponse, HttpResponse
+    from .jsonable_encoder import jsonable_encoder
+    from .pydantic_utilities import (
+        IS_PYDANTIC_V2,
+        UniversalBaseModel,
+        UniversalRootModel,
+        parse_obj_as,
+        universal_field_validator,
+        universal_root_validator,
+        update_forward_refs,
+    )
+    from .query_encoder import encode_query
+    from .remove_none_from_dict import remove_none_from_dict
+    from .request_options import RequestOptions
+    from .serialization import FieldMetadata, convert_and_respect_annotation_metadata
+_dynamic_imports: typing.Dict[str, str] = {
+    "ApiError": ".api_error",
+    "AsyncClientWrapper": ".client_wrapper",
+    "AsyncHttpClient": ".http_client",
+    "AsyncHttpResponse": ".http_response",
+    "BaseClientWrapper": ".client_wrapper",
+    "FieldMetadata": ".serialization",
+    "File": ".file",
+    "HttpClient": ".http_client",
+    "HttpResponse": ".http_response",
+    "IS_PYDANTIC_V2": ".pydantic_utilities",
+    "RequestOptions": ".request_options",
+    "SyncClientWrapper": ".client_wrapper",
+    "UniversalBaseModel": ".pydantic_utilities",
+    "UniversalRootModel": ".pydantic_utilities",
+    "convert_and_respect_annotation_metadata": ".serialization",
+    "convert_file_dict_to_httpx_tuples": ".file",
+    "encode_query": ".query_encoder",
+    "jsonable_encoder": ".jsonable_encoder",
+    "parse_obj_as": ".pydantic_utilities",
+    "remove_none_from_dict": ".remove_none_from_dict",
+    "serialize_datetime": ".datetime_utils",
+    "universal_field_validator": ".pydantic_utilities",
+    "universal_root_validator": ".pydantic_utilities",
+    "update_forward_refs": ".pydantic_utilities",
+    "with_content_type": ".file",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
 
 __all__ = [
     "ApiError",

athena/core/client_wrapper.py

@@ -22,10 +22,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "athena-intelligence/0.1.230",
+            "User-Agent": "athena-intelligence/0.1.242",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "athena-intelligence",
-            "X-Fern-SDK-Version": "0.1.230",
+            "X-Fern-SDK-Version": "0.1.242",
             **(self.get_custom_headers() or {}),
         }
         headers["X-API-KEY"] = self.api_key

athena/core/force_multipart.py

@@ -1,7 +1,9 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from typing import Any, Dict
 
-class ForceMultipartDict(dict):
+
+class ForceMultipartDict(Dict[str, Any]):
     """
     A dictionary subclass that always evaluates to True in boolean contexts.
 
@@ -9,7 +11,7 @@ class ForceMultipartDict(dict):
     the dictionary is empty, which would normally evaluate to False.
     """
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return True
 
 

athena/core/http_response.py

@@ -4,8 +4,8 @@ from typing import Dict, Generic, TypeVar
 
 import httpx
 
+# Generic to represent the underlying type of the data wrapped by the HTTP response.
 T = TypeVar("T")
-"""Generic to represent the underlying type of the data wrapped by the HTTP response."""
 
 
 class BaseHttpResponse:

athena/core/pydantic_utilities.py

@@ -61,7 +61,7 @@ class UniversalBaseModel(pydantic.BaseModel):
 
         @pydantic.model_serializer(mode="plain", when_used="json")  # type: ignore[attr-defined]
         def serialize_model(self) -> Any:  # type: ignore[name-defined]
-            serialized = self.model_dump()
+            serialized = self.dict()  # type: ignore[attr-defined]
             data = {k: serialize_datetime(v) if isinstance(v, dt.datetime) else v for k, v in serialized.items()}
             return data
 
@@ -147,7 +147,10 @@ class UniversalBaseModel(pydantic.BaseModel):
 
             dict_dump = super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
 
-        return convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write")
+        return cast(
+            Dict[str, Any],
+            convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write"),
+        )
 
 
 def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) -> List[Any]:

athena/errors/__init__.py

@@ -2,13 +2,48 @@
 
 # isort: skip_file
 
-from .bad_request_error import BadRequestError
-from .content_too_large_error import ContentTooLargeError
-from .internal_server_error import InternalServerError
-from .not_found_error import NotFoundError
-from .unauthorized_error import UnauthorizedError
-from .unprocessable_entity_error import UnprocessableEntityError
-from .unsupported_media_type_error import UnsupportedMediaTypeError
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .bad_request_error import BadRequestError
+    from .content_too_large_error import ContentTooLargeError
+    from .internal_server_error import InternalServerError
+    from .not_found_error import NotFoundError
+    from .unauthorized_error import UnauthorizedError
+    from .unprocessable_entity_error import UnprocessableEntityError
+    from .unsupported_media_type_error import UnsupportedMediaTypeError
+_dynamic_imports: typing.Dict[str, str] = {
+    "BadRequestError": ".bad_request_error",
+    "ContentTooLargeError": ".content_too_large_error",
+    "InternalServerError": ".internal_server_error",
+    "NotFoundError": ".not_found_error",
+    "UnauthorizedError": ".unauthorized_error",
+    "UnprocessableEntityError": ".unprocessable_entity_error",
+    "UnsupportedMediaTypeError": ".unsupported_media_type_error",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
 
 __all__ = [
     "BadRequestError",

athena/query/__init__.py

@@ -2,6 +2,33 @@
 
 # isort: skip_file
 
-from .types import QueryExecuteRequestDatabaseAssetIds
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .types import QueryExecuteRequestDatabaseAssetIds
+_dynamic_imports: typing.Dict[str, str] = {"QueryExecuteRequestDatabaseAssetIds": ".types"}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
 
 __all__ = ["QueryExecuteRequestDatabaseAssetIds"]

athena/query/types/__init__.py

@@ -2,6 +2,35 @@
 
 # isort: skip_file
 
-from .query_execute_request_database_asset_ids import QueryExecuteRequestDatabaseAssetIds
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .query_execute_request_database_asset_ids import QueryExecuteRequestDatabaseAssetIds
+_dynamic_imports: typing.Dict[str, str] = {
+    "QueryExecuteRequestDatabaseAssetIds": ".query_execute_request_database_asset_ids"
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
 
 __all__ = ["QueryExecuteRequestDatabaseAssetIds"]

athena/tools/__init__.py

@@ -2,7 +2,51 @@
 
 # isort: skip_file
 
-from .types import ToolsDataFrameRequestColumnsItem
-from . import calendar, email, sheets, structured_data_extractor, tasks
+import typing
+from importlib import import_module
 
-__all__ = ["ToolsDataFrameRequestColumnsItem", "calendar", "email", "sheets", "structured_data_extractor", "tasks"]
+if typing.TYPE_CHECKING:
+    from .types import ToolsDataFrameRequestColumnsItem
+    from . import calendar, email, sheets, structured_data_extractor, tasks
+    from .sheets import UpdateSheetRangeRequestValuesItemItem
+_dynamic_imports: typing.Dict[str, str] = {
+    "ToolsDataFrameRequestColumnsItem": ".types",
+    "UpdateSheetRangeRequestValuesItemItem": ".sheets",
+    "calendar": ".calendar",
+    "email": ".email",
+    "sheets": ".sheets",
+    "structured_data_extractor": ".structured_data_extractor",
+    "tasks": ".tasks",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = [
+    "ToolsDataFrameRequestColumnsItem",
+    "UpdateSheetRangeRequestValuesItemItem",
+    "calendar",
+    "email",
+    "sheets",
+    "structured_data_extractor",
+    "tasks",
+]