chore(internal): codegen related update (#72)

Author: stainless-app[bot]

src/asktable/_client.py

@@ -8,7 +8,7 @@
 
 import httpx
 
-from . import _exceptions
+from . import resources, _exceptions
 from ._qs import Querystring
 from ._types import (
     NOT_GIVEN,
@@ -24,25 +24,20 @@
     get_async_library,
 )
 from ._version import __version__
-from .resources import auth, bots, roles, caches, policies, integration, securetunnels, business_glossary
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import AsktableError, APIStatusError
 from ._base_client import (
     DEFAULT_MAX_RETRIES,
     SyncAPIClient,
     AsyncAPIClient,
 )
-from .resources.sys import sys
-from .resources.chats import chats
-from .resources.extapis import extapis
-from .resources.datasources import datasources
-from .resources.single_turn import single_turn
 
 __all__ = [
     "Timeout",
     "Transport",
     "ProxiesTypes",
     "RequestOptions",
+    "resources",
     "Asktable",
     "AsyncAsktable",
     "Client",
@@ -51,19 +46,19 @@
 
 
 class Asktable(SyncAPIClient):
-    sys: sys.SysResource
-    securetunnels: securetunnels.SecuretunnelsResource
-    roles: roles.RolesResource
-    policies: policies.PoliciesResource
-    chats: chats.ChatsResource
-    datasources: datasources.DatasourcesResource
-    bots: bots.BotsResource
-    extapis: extapis.ExtapisResource
-    auth: auth.AuthResource
-    single_turn: single_turn.SingleTurnResource
-    caches: caches.CachesResource
-    integration: integration.IntegrationResource
-    business_glossary: business_glossary.BusinessGlossaryResource
+    sys: resources.SysResource
+    securetunnels: resources.SecuretunnelsResource
+    roles: resources.RolesResource
+    policies: resources.PoliciesResource
+    chats: resources.ChatsResource
+    datasources: resources.DatasourcesResource
+    bots: resources.BotsResource
+    extapis: resources.ExtapisResource
+    auth: resources.AuthResource
+    single_turn: resources.SingleTurnResource
+    caches: resources.CachesResource
+    integration: resources.IntegrationResource
+    business_glossary: resources.BusinessGlossaryResource
     with_raw_response: AsktableWithRawResponse
     with_streaming_response: AsktableWithStreamedResponse
 
@@ -121,19 +116,19 @@ def __init__(
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.sys = sys.SysResource(self)
-        self.securetunnels = securetunnels.SecuretunnelsResource(self)
-        self.roles = roles.RolesResource(self)
-        self.policies = policies.PoliciesResource(self)
-        self.chats = chats.ChatsResource(self)
-        self.datasources = datasources.DatasourcesResource(self)
-        self.bots = bots.BotsResource(self)
-        self.extapis = extapis.ExtapisResource(self)
-        self.auth = auth.AuthResource(self)
-        self.single_turn = single_turn.SingleTurnResource(self)
-        self.caches = caches.CachesResource(self)
-        self.integration = integration.IntegrationResource(self)
-        self.business_glossary = business_glossary.BusinessGlossaryResource(self)
+        self.sys = resources.SysResource(self)
+        self.securetunnels = resources.SecuretunnelsResource(self)
+        self.roles = resources.RolesResource(self)
+        self.policies = resources.PoliciesResource(self)
+        self.chats = resources.ChatsResource(self)
+        self.datasources = resources.DatasourcesResource(self)
+        self.bots = resources.BotsResource(self)
+        self.extapis = resources.ExtapisResource(self)
+        self.auth = resources.AuthResource(self)
+        self.single_turn = resources.SingleTurnResource(self)
+        self.caches = resources.CachesResource(self)
+        self.integration = resources.IntegrationResource(self)
+        self.business_glossary = resources.BusinessGlossaryResource(self)
         self.with_raw_response = AsktableWithRawResponse(self)
         self.with_streaming_response = AsktableWithStreamedResponse(self)
 
@@ -243,19 +238,19 @@ def _make_status_error(
 
 
 class AsyncAsktable(AsyncAPIClient):
-    sys: sys.AsyncSysResource
-    securetunnels: securetunnels.AsyncSecuretunnelsResource
-    roles: roles.AsyncRolesResource
-    policies: policies.AsyncPoliciesResource
-    chats: chats.AsyncChatsResource
-    datasources: datasources.AsyncDatasourcesResource
-    bots: bots.AsyncBotsResource
-    extapis: extapis.AsyncExtapisResource
-    auth: auth.AsyncAuthResource
-    single_turn: single_turn.AsyncSingleTurnResource
-    caches: caches.AsyncCachesResource
-    integration: integration.AsyncIntegrationResource
-    business_glossary: business_glossary.AsyncBusinessGlossaryResource
+    sys: resources.AsyncSysResource
+    securetunnels: resources.AsyncSecuretunnelsResource
+    roles: resources.AsyncRolesResource
+    policies: resources.AsyncPoliciesResource
+    chats: resources.AsyncChatsResource
+    datasources: resources.AsyncDatasourcesResource
+    bots: resources.AsyncBotsResource
+    extapis: resources.AsyncExtapisResource
+    auth: resources.AsyncAuthResource
+    single_turn: resources.AsyncSingleTurnResource
+    caches: resources.AsyncCachesResource
+    integration: resources.AsyncIntegrationResource
+    business_glossary: resources.AsyncBusinessGlossaryResource
     with_raw_response: AsyncAsktableWithRawResponse
     with_streaming_response: AsyncAsktableWithStreamedResponse
 
@@ -313,19 +308,19 @@ def __init__(
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.sys = sys.AsyncSysResource(self)
-        self.securetunnels = securetunnels.AsyncSecuretunnelsResource(self)
-        self.roles = roles.AsyncRolesResource(self)
-        self.policies = policies.AsyncPoliciesResource(self)
-        self.chats = chats.AsyncChatsResource(self)
-        self.datasources = datasources.AsyncDatasourcesResource(self)
-        self.bots = bots.AsyncBotsResource(self)
-        self.extapis = extapis.AsyncExtapisResource(self)
-        self.auth = auth.AsyncAuthResource(self)
-        self.single_turn = single_turn.AsyncSingleTurnResource(self)
-        self.caches = caches.AsyncCachesResource(self)
-        self.integration = integration.AsyncIntegrationResource(self)
-        self.business_glossary = business_glossary.AsyncBusinessGlossaryResource(self)
+        self.sys = resources.AsyncSysResource(self)
+        self.securetunnels = resources.AsyncSecuretunnelsResource(self)
+        self.roles = resources.AsyncRolesResource(self)
+        self.policies = resources.AsyncPoliciesResource(self)
+        self.chats = resources.AsyncChatsResource(self)
+        self.datasources = resources.AsyncDatasourcesResource(self)
+        self.bots = resources.AsyncBotsResource(self)
+        self.extapis = resources.AsyncExtapisResource(self)
+        self.auth = resources.AsyncAuthResource(self)
+        self.single_turn = resources.AsyncSingleTurnResource(self)
+        self.caches = resources.AsyncCachesResource(self)
+        self.integration = resources.AsyncIntegrationResource(self)
+        self.business_glossary = resources.AsyncBusinessGlossaryResource(self)
         self.with_raw_response = AsyncAsktableWithRawResponse(self)
         self.with_streaming_response = AsyncAsktableWithStreamedResponse(self)
 
@@ -436,76 +431,70 @@ def _make_status_error(
 
 class AsktableWithRawResponse:
     def __init__(self, client: Asktable) -> None:
-        self.sys = sys.SysResourceWithRawResponse(client.sys)
-        self.securetunnels = securetunnels.SecuretunnelsResourceWithRawResponse(client.securetunnels)
-        self.roles = roles.RolesResourceWithRawResponse(client.roles)
-        self.policies = policies.PoliciesResourceWithRawResponse(client.policies)
-        self.chats = chats.ChatsResourceWithRawResponse(client.chats)
-        self.datasources = datasources.DatasourcesResourceWithRawResponse(client.datasources)
-        self.bots = bots.BotsResourceWithRawResponse(client.bots)
-        self.extapis = extapis.ExtapisResourceWithRawResponse(client.extapis)
-        self.auth = auth.AuthResourceWithRawResponse(client.auth)
-        self.single_turn = single_turn.SingleTurnResourceWithRawResponse(client.single_turn)
-        self.caches = caches.CachesResourceWithRawResponse(client.caches)
-        self.integration = integration.IntegrationResourceWithRawResponse(client.integration)
-        self.business_glossary = business_glossary.BusinessGlossaryResourceWithRawResponse(client.business_glossary)
+        self.sys = resources.SysResourceWithRawResponse(client.sys)
+        self.securetunnels = resources.SecuretunnelsResourceWithRawResponse(client.securetunnels)
+        self.roles = resources.RolesResourceWithRawResponse(client.roles)
+        self.policies = resources.PoliciesResourceWithRawResponse(client.policies)
+        self.chats = resources.ChatsResourceWithRawResponse(client.chats)
+        self.datasources = resources.DatasourcesResourceWithRawResponse(client.datasources)
+        self.bots = resources.BotsResourceWithRawResponse(client.bots)
+        self.extapis = resources.ExtapisResourceWithRawResponse(client.extapis)
+        self.auth = resources.AuthResourceWithRawResponse(client.auth)
+        self.single_turn = resources.SingleTurnResourceWithRawResponse(client.single_turn)
+        self.caches = resources.CachesResourceWithRawResponse(client.caches)
+        self.integration = resources.IntegrationResourceWithRawResponse(client.integration)
+        self.business_glossary = resources.BusinessGlossaryResourceWithRawResponse(client.business_glossary)
 
 
 class AsyncAsktableWithRawResponse:
     def __init__(self, client: AsyncAsktable) -> None:
-        self.sys = sys.AsyncSysResourceWithRawResponse(client.sys)
-        self.securetunnels = securetunnels.AsyncSecuretunnelsResourceWithRawResponse(client.securetunnels)
-        self.roles = roles.AsyncRolesResourceWithRawResponse(client.roles)
-        self.policies = policies.AsyncPoliciesResourceWithRawResponse(client.policies)
-        self.chats = chats.AsyncChatsResourceWithRawResponse(client.chats)
-        self.datasources = datasources.AsyncDatasourcesResourceWithRawResponse(client.datasources)
-        self.bots = bots.AsyncBotsResourceWithRawResponse(client.bots)
-        self.extapis = extapis.AsyncExtapisResourceWithRawResponse(client.extapis)
-        self.auth = auth.AsyncAuthResourceWithRawResponse(client.auth)
-        self.single_turn = single_turn.AsyncSingleTurnResourceWithRawResponse(client.single_turn)
-        self.caches = caches.AsyncCachesResourceWithRawResponse(client.caches)
-        self.integration = integration.AsyncIntegrationResourceWithRawResponse(client.integration)
-        self.business_glossary = business_glossary.AsyncBusinessGlossaryResourceWithRawResponse(
-            client.business_glossary
-        )
+        self.sys = resources.AsyncSysResourceWithRawResponse(client.sys)
+        self.securetunnels = resources.AsyncSecuretunnelsResourceWithRawResponse(client.securetunnels)
+        self.roles = resources.AsyncRolesResourceWithRawResponse(client.roles)
+        self.policies = resources.AsyncPoliciesResourceWithRawResponse(client.policies)
+        self.chats = resources.AsyncChatsResourceWithRawResponse(client.chats)
+        self.datasources = resources.AsyncDatasourcesResourceWithRawResponse(client.datasources)
+        self.bots = resources.AsyncBotsResourceWithRawResponse(client.bots)
+        self.extapis = resources.AsyncExtapisResourceWithRawResponse(client.extapis)
+        self.auth = resources.AsyncAuthResourceWithRawResponse(client.auth)
+        self.single_turn = resources.AsyncSingleTurnResourceWithRawResponse(client.single_turn)
+        self.caches = resources.AsyncCachesResourceWithRawResponse(client.caches)
+        self.integration = resources.AsyncIntegrationResourceWithRawResponse(client.integration)
+        self.business_glossary = resources.AsyncBusinessGlossaryResourceWithRawResponse(client.business_glossary)
 
 
 class AsktableWithStreamedResponse:
     def __init__(self, client: Asktable) -> None:
-        self.sys = sys.SysResourceWithStreamingResponse(client.sys)
-        self.securetunnels = securetunnels.SecuretunnelsResourceWithStreamingResponse(client.securetunnels)
-        self.roles = roles.RolesResourceWithStreamingResponse(client.roles)
-        self.policies = policies.PoliciesResourceWithStreamingResponse(client.policies)
-        self.chats = chats.ChatsResourceWithStreamingResponse(client.chats)
-        self.datasources = datasources.DatasourcesResourceWithStreamingResponse(client.datasources)
-        self.bots = bots.BotsResourceWithStreamingResponse(client.bots)
-        self.extapis = extapis.ExtapisResourceWithStreamingResponse(client.extapis)
-        self.auth = auth.AuthResourceWithStreamingResponse(client.auth)
-        self.single_turn = single_turn.SingleTurnResourceWithStreamingResponse(client.single_turn)
-        self.caches = caches.CachesResourceWithStreamingResponse(client.caches)
-        self.integration = integration.IntegrationResourceWithStreamingResponse(client.integration)
-        self.business_glossary = business_glossary.BusinessGlossaryResourceWithStreamingResponse(
-            client.business_glossary
-        )
+        self.sys = resources.SysResourceWithStreamingResponse(client.sys)
+        self.securetunnels = resources.SecuretunnelsResourceWithStreamingResponse(client.securetunnels)
+        self.roles = resources.RolesResourceWithStreamingResponse(client.roles)
+        self.policies = resources.PoliciesResourceWithStreamingResponse(client.policies)
+        self.chats = resources.ChatsResourceWithStreamingResponse(client.chats)
+        self.datasources = resources.DatasourcesResourceWithStreamingResponse(client.datasources)
+        self.bots = resources.BotsResourceWithStreamingResponse(client.bots)
+        self.extapis = resources.ExtapisResourceWithStreamingResponse(client.extapis)
+        self.auth = resources.AuthResourceWithStreamingResponse(client.auth)
+        self.single_turn = resources.SingleTurnResourceWithStreamingResponse(client.single_turn)
+        self.caches = resources.CachesResourceWithStreamingResponse(client.caches)
+        self.integration = resources.IntegrationResourceWithStreamingResponse(client.integration)
+        self.business_glossary = resources.BusinessGlossaryResourceWithStreamingResponse(client.business_glossary)
 
 
 class AsyncAsktableWithStreamedResponse:
     def __init__(self, client: AsyncAsktable) -> None:
-        self.sys = sys.AsyncSysResourceWithStreamingResponse(client.sys)
-        self.securetunnels = securetunnels.AsyncSecuretunnelsResourceWithStreamingResponse(client.securetunnels)
-        self.roles = roles.AsyncRolesResourceWithStreamingResponse(client.roles)
-        self.policies = policies.AsyncPoliciesResourceWithStreamingResponse(client.policies)
-        self.chats = chats.AsyncChatsResourceWithStreamingResponse(client.chats)
-        self.datasources = datasources.AsyncDatasourcesResourceWithStreamingResponse(client.datasources)
-        self.bots = bots.AsyncBotsResourceWithStreamingResponse(client.bots)
-        self.extapis = extapis.AsyncExtapisResourceWithStreamingResponse(client.extapis)
-        self.auth = auth.AsyncAuthResourceWithStreamingResponse(client.auth)
-        self.single_turn = single_turn.AsyncSingleTurnResourceWithStreamingResponse(client.single_turn)
-        self.caches = caches.AsyncCachesResourceWithStreamingResponse(client.caches)
-        self.integration = integration.AsyncIntegrationResourceWithStreamingResponse(client.integration)
-        self.business_glossary = business_glossary.AsyncBusinessGlossaryResourceWithStreamingResponse(
-            client.business_glossary
-        )
+        self.sys = resources.AsyncSysResourceWithStreamingResponse(client.sys)
+        self.securetunnels = resources.AsyncSecuretunnelsResourceWithStreamingResponse(client.securetunnels)
+        self.roles = resources.AsyncRolesResourceWithStreamingResponse(client.roles)
+        self.policies = resources.AsyncPoliciesResourceWithStreamingResponse(client.policies)
+        self.chats = resources.AsyncChatsResourceWithStreamingResponse(client.chats)
+        self.datasources = resources.AsyncDatasourcesResourceWithStreamingResponse(client.datasources)
+        self.bots = resources.AsyncBotsResourceWithStreamingResponse(client.bots)
+        self.extapis = resources.AsyncExtapisResourceWithStreamingResponse(client.extapis)
+        self.auth = resources.AsyncAuthResourceWithStreamingResponse(client.auth)
+        self.single_turn = resources.AsyncSingleTurnResourceWithStreamingResponse(client.single_turn)
+        self.caches = resources.AsyncCachesResourceWithStreamingResponse(client.caches)
+        self.integration = resources.AsyncIntegrationResourceWithStreamingResponse(client.integration)
+        self.business_glossary = resources.AsyncBusinessGlossaryResourceWithStreamingResponse(client.business_glossary)
 
 
 Client = Asktable

src/asktable/resources/sys/sys.py

@@ -2,16 +2,17 @@
 
 from __future__ import annotations
 
-from ..._compat import cached_property
-from ..._resource import SyncAPIResource, AsyncAPIResource
-from .projects.projects import (
+from .projects import (
     ProjectsResource,
     AsyncProjectsResource,
     ProjectsResourceWithRawResponse,
     AsyncProjectsResourceWithRawResponse,
     ProjectsResourceWithStreamingResponse,
     AsyncProjectsResourceWithStreamingResponse,
 )
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from .projects.projects import ProjectsResource, AsyncProjectsResource
 
 __all__ = ["SysResource", "AsyncSysResource"]