From dcf8544e5f5edd785eb6cb6768106d44877a5c70 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 18 Dec 2024 05:05:48 +0000 Subject: [PATCH] chore(internal): codegen related update (#78) --- README.md | 10 ++ src/dataherald/_client.py | 190 ++++++++++++++++++++------------------ tests/test_client.py | 8 +- 3 files changed, 114 insertions(+), 94 deletions(-) diff --git a/README.md b/README.md index b655fbf..8556333 100644 --- a/README.md +++ b/README.md @@ -311,6 +311,16 @@ client.with_options(http_client=DefaultHttpxClient(...)) By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting. +```py +from dataherald import Dataherald + +with Dataherald() as client: + # make requests here + ... + +# HTTP client is now closed +``` + ## Versioning This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions: diff --git a/src/dataherald/_client.py b/src/dataherald/_client.py index b0077d0..38ada33 100644 --- a/src/dataherald/_client.py +++ b/src/dataherald/_client.py @@ -8,7 +8,7 @@ import httpx -from . import resources, _exceptions +from . import _exceptions from ._qs import Querystring from ._types import ( NOT_GIVEN, @@ -24,6 +24,7 @@ get_async_library, ) from ._version import __version__ +from .resources import engine, heartbeat, finetunings, generations, golden_sqls, nl_generations, table_descriptions from ._streaming import Stream as Stream, AsyncStream as AsyncStream from ._exceptions import APIStatusError, DataheraldError from ._base_client import ( @@ -31,6 +32,10 @@ SyncAPIClient, AsyncAPIClient, ) +from .resources.prompts import prompts +from .resources.instructions import instructions +from .resources.sql_generations import sql_generations +from .resources.database_connections import database_connections __all__ = [ "ENVIRONMENTS", @@ -38,7 +43,6 @@ "Transport", "ProxiesTypes", "RequestOptions", - "resources", "Dataherald", "AsyncDataherald", "Client", @@ -52,17 +56,17 @@ class Dataherald(SyncAPIClient): - database_connections: resources.DatabaseConnectionsResource - finetunings: resources.FinetuningsResource - golden_sqls: resources.GoldenSqlsResource - instructions: resources.InstructionsResource - generations: resources.GenerationsResource - prompts: resources.PromptsResource - sql_generations: resources.SqlGenerationsResource - nl_generations: resources.NlGenerationsResource - table_descriptions: resources.TableDescriptionsResource - heartbeat: resources.HeartbeatResource - engine: resources.EngineResource + database_connections: database_connections.DatabaseConnectionsResource + finetunings: finetunings.FinetuningsResource + golden_sqls: golden_sqls.GoldenSqlsResource + instructions: instructions.InstructionsResource + generations: generations.GenerationsResource + prompts: prompts.PromptsResource + sql_generations: sql_generations.SqlGenerationsResource + nl_generations: nl_generations.NlGenerationsResource + table_descriptions: table_descriptions.TableDescriptionsResource + heartbeat: heartbeat.HeartbeatResource + engine: engine.EngineResource with_raw_response: DataheraldWithRawResponse with_streaming_response: DataheraldWithStreamedResponse @@ -144,17 +148,17 @@ def __init__( _strict_response_validation=_strict_response_validation, ) - self.database_connections = resources.DatabaseConnectionsResource(self) - self.finetunings = resources.FinetuningsResource(self) - self.golden_sqls = resources.GoldenSqlsResource(self) - self.instructions = resources.InstructionsResource(self) - self.generations = resources.GenerationsResource(self) - self.prompts = resources.PromptsResource(self) - self.sql_generations = resources.SqlGenerationsResource(self) - self.nl_generations = resources.NlGenerationsResource(self) - self.table_descriptions = resources.TableDescriptionsResource(self) - self.heartbeat = resources.HeartbeatResource(self) - self.engine = resources.EngineResource(self) + self.database_connections = database_connections.DatabaseConnectionsResource(self) + self.finetunings = finetunings.FinetuningsResource(self) + self.golden_sqls = golden_sqls.GoldenSqlsResource(self) + self.instructions = instructions.InstructionsResource(self) + self.generations = generations.GenerationsResource(self) + self.prompts = prompts.PromptsResource(self) + self.sql_generations = sql_generations.SqlGenerationsResource(self) + self.nl_generations = nl_generations.NlGenerationsResource(self) + self.table_descriptions = table_descriptions.TableDescriptionsResource(self) + self.heartbeat = heartbeat.HeartbeatResource(self) + self.engine = engine.EngineResource(self) self.with_raw_response = DataheraldWithRawResponse(self) self.with_streaming_response = DataheraldWithStreamedResponse(self) @@ -266,17 +270,17 @@ def _make_status_error( class AsyncDataherald(AsyncAPIClient): - database_connections: resources.AsyncDatabaseConnectionsResource - finetunings: resources.AsyncFinetuningsResource - golden_sqls: resources.AsyncGoldenSqlsResource - instructions: resources.AsyncInstructionsResource - generations: resources.AsyncGenerationsResource - prompts: resources.AsyncPromptsResource - sql_generations: resources.AsyncSqlGenerationsResource - nl_generations: resources.AsyncNlGenerationsResource - table_descriptions: resources.AsyncTableDescriptionsResource - heartbeat: resources.AsyncHeartbeatResource - engine: resources.AsyncEngineResource + database_connections: database_connections.AsyncDatabaseConnectionsResource + finetunings: finetunings.AsyncFinetuningsResource + golden_sqls: golden_sqls.AsyncGoldenSqlsResource + instructions: instructions.AsyncInstructionsResource + generations: generations.AsyncGenerationsResource + prompts: prompts.AsyncPromptsResource + sql_generations: sql_generations.AsyncSqlGenerationsResource + nl_generations: nl_generations.AsyncNlGenerationsResource + table_descriptions: table_descriptions.AsyncTableDescriptionsResource + heartbeat: heartbeat.AsyncHeartbeatResource + engine: engine.AsyncEngineResource with_raw_response: AsyncDataheraldWithRawResponse with_streaming_response: AsyncDataheraldWithStreamedResponse @@ -358,17 +362,17 @@ def __init__( _strict_response_validation=_strict_response_validation, ) - self.database_connections = resources.AsyncDatabaseConnectionsResource(self) - self.finetunings = resources.AsyncFinetuningsResource(self) - self.golden_sqls = resources.AsyncGoldenSqlsResource(self) - self.instructions = resources.AsyncInstructionsResource(self) - self.generations = resources.AsyncGenerationsResource(self) - self.prompts = resources.AsyncPromptsResource(self) - self.sql_generations = resources.AsyncSqlGenerationsResource(self) - self.nl_generations = resources.AsyncNlGenerationsResource(self) - self.table_descriptions = resources.AsyncTableDescriptionsResource(self) - self.heartbeat = resources.AsyncHeartbeatResource(self) - self.engine = resources.AsyncEngineResource(self) + self.database_connections = database_connections.AsyncDatabaseConnectionsResource(self) + self.finetunings = finetunings.AsyncFinetuningsResource(self) + self.golden_sqls = golden_sqls.AsyncGoldenSqlsResource(self) + self.instructions = instructions.AsyncInstructionsResource(self) + self.generations = generations.AsyncGenerationsResource(self) + self.prompts = prompts.AsyncPromptsResource(self) + self.sql_generations = sql_generations.AsyncSqlGenerationsResource(self) + self.nl_generations = nl_generations.AsyncNlGenerationsResource(self) + self.table_descriptions = table_descriptions.AsyncTableDescriptionsResource(self) + self.heartbeat = heartbeat.AsyncHeartbeatResource(self) + self.engine = engine.AsyncEngineResource(self) self.with_raw_response = AsyncDataheraldWithRawResponse(self) self.with_streaming_response = AsyncDataheraldWithStreamedResponse(self) @@ -481,70 +485,76 @@ def _make_status_error( class DataheraldWithRawResponse: def __init__(self, client: Dataherald) -> None: - self.database_connections = resources.DatabaseConnectionsResourceWithRawResponse(client.database_connections) - self.finetunings = resources.FinetuningsResourceWithRawResponse(client.finetunings) - self.golden_sqls = resources.GoldenSqlsResourceWithRawResponse(client.golden_sqls) - self.instructions = resources.InstructionsResourceWithRawResponse(client.instructions) - self.generations = resources.GenerationsResourceWithRawResponse(client.generations) - self.prompts = resources.PromptsResourceWithRawResponse(client.prompts) - self.sql_generations = resources.SqlGenerationsResourceWithRawResponse(client.sql_generations) - self.nl_generations = resources.NlGenerationsResourceWithRawResponse(client.nl_generations) - self.table_descriptions = resources.TableDescriptionsResourceWithRawResponse(client.table_descriptions) - self.heartbeat = resources.HeartbeatResourceWithRawResponse(client.heartbeat) - self.engine = resources.EngineResourceWithRawResponse(client.engine) + self.database_connections = database_connections.DatabaseConnectionsResourceWithRawResponse( + client.database_connections + ) + self.finetunings = finetunings.FinetuningsResourceWithRawResponse(client.finetunings) + self.golden_sqls = golden_sqls.GoldenSqlsResourceWithRawResponse(client.golden_sqls) + self.instructions = instructions.InstructionsResourceWithRawResponse(client.instructions) + self.generations = generations.GenerationsResourceWithRawResponse(client.generations) + self.prompts = prompts.PromptsResourceWithRawResponse(client.prompts) + self.sql_generations = sql_generations.SqlGenerationsResourceWithRawResponse(client.sql_generations) + self.nl_generations = nl_generations.NlGenerationsResourceWithRawResponse(client.nl_generations) + self.table_descriptions = table_descriptions.TableDescriptionsResourceWithRawResponse(client.table_descriptions) + self.heartbeat = heartbeat.HeartbeatResourceWithRawResponse(client.heartbeat) + self.engine = engine.EngineResourceWithRawResponse(client.engine) class AsyncDataheraldWithRawResponse: def __init__(self, client: AsyncDataherald) -> None: - self.database_connections = resources.AsyncDatabaseConnectionsResourceWithRawResponse( + self.database_connections = database_connections.AsyncDatabaseConnectionsResourceWithRawResponse( client.database_connections ) - self.finetunings = resources.AsyncFinetuningsResourceWithRawResponse(client.finetunings) - self.golden_sqls = resources.AsyncGoldenSqlsResourceWithRawResponse(client.golden_sqls) - self.instructions = resources.AsyncInstructionsResourceWithRawResponse(client.instructions) - self.generations = resources.AsyncGenerationsResourceWithRawResponse(client.generations) - self.prompts = resources.AsyncPromptsResourceWithRawResponse(client.prompts) - self.sql_generations = resources.AsyncSqlGenerationsResourceWithRawResponse(client.sql_generations) - self.nl_generations = resources.AsyncNlGenerationsResourceWithRawResponse(client.nl_generations) - self.table_descriptions = resources.AsyncTableDescriptionsResourceWithRawResponse(client.table_descriptions) - self.heartbeat = resources.AsyncHeartbeatResourceWithRawResponse(client.heartbeat) - self.engine = resources.AsyncEngineResourceWithRawResponse(client.engine) + self.finetunings = finetunings.AsyncFinetuningsResourceWithRawResponse(client.finetunings) + self.golden_sqls = golden_sqls.AsyncGoldenSqlsResourceWithRawResponse(client.golden_sqls) + self.instructions = instructions.AsyncInstructionsResourceWithRawResponse(client.instructions) + self.generations = generations.AsyncGenerationsResourceWithRawResponse(client.generations) + self.prompts = prompts.AsyncPromptsResourceWithRawResponse(client.prompts) + self.sql_generations = sql_generations.AsyncSqlGenerationsResourceWithRawResponse(client.sql_generations) + self.nl_generations = nl_generations.AsyncNlGenerationsResourceWithRawResponse(client.nl_generations) + self.table_descriptions = table_descriptions.AsyncTableDescriptionsResourceWithRawResponse( + client.table_descriptions + ) + self.heartbeat = heartbeat.AsyncHeartbeatResourceWithRawResponse(client.heartbeat) + self.engine = engine.AsyncEngineResourceWithRawResponse(client.engine) class DataheraldWithStreamedResponse: def __init__(self, client: Dataherald) -> None: - self.database_connections = resources.DatabaseConnectionsResourceWithStreamingResponse( + self.database_connections = database_connections.DatabaseConnectionsResourceWithStreamingResponse( client.database_connections ) - self.finetunings = resources.FinetuningsResourceWithStreamingResponse(client.finetunings) - self.golden_sqls = resources.GoldenSqlsResourceWithStreamingResponse(client.golden_sqls) - self.instructions = resources.InstructionsResourceWithStreamingResponse(client.instructions) - self.generations = resources.GenerationsResourceWithStreamingResponse(client.generations) - self.prompts = resources.PromptsResourceWithStreamingResponse(client.prompts) - self.sql_generations = resources.SqlGenerationsResourceWithStreamingResponse(client.sql_generations) - self.nl_generations = resources.NlGenerationsResourceWithStreamingResponse(client.nl_generations) - self.table_descriptions = resources.TableDescriptionsResourceWithStreamingResponse(client.table_descriptions) - self.heartbeat = resources.HeartbeatResourceWithStreamingResponse(client.heartbeat) - self.engine = resources.EngineResourceWithStreamingResponse(client.engine) + self.finetunings = finetunings.FinetuningsResourceWithStreamingResponse(client.finetunings) + self.golden_sqls = golden_sqls.GoldenSqlsResourceWithStreamingResponse(client.golden_sqls) + self.instructions = instructions.InstructionsResourceWithStreamingResponse(client.instructions) + self.generations = generations.GenerationsResourceWithStreamingResponse(client.generations) + self.prompts = prompts.PromptsResourceWithStreamingResponse(client.prompts) + self.sql_generations = sql_generations.SqlGenerationsResourceWithStreamingResponse(client.sql_generations) + self.nl_generations = nl_generations.NlGenerationsResourceWithStreamingResponse(client.nl_generations) + self.table_descriptions = table_descriptions.TableDescriptionsResourceWithStreamingResponse( + client.table_descriptions + ) + self.heartbeat = heartbeat.HeartbeatResourceWithStreamingResponse(client.heartbeat) + self.engine = engine.EngineResourceWithStreamingResponse(client.engine) class AsyncDataheraldWithStreamedResponse: def __init__(self, client: AsyncDataherald) -> None: - self.database_connections = resources.AsyncDatabaseConnectionsResourceWithStreamingResponse( + self.database_connections = database_connections.AsyncDatabaseConnectionsResourceWithStreamingResponse( client.database_connections ) - self.finetunings = resources.AsyncFinetuningsResourceWithStreamingResponse(client.finetunings) - self.golden_sqls = resources.AsyncGoldenSqlsResourceWithStreamingResponse(client.golden_sqls) - self.instructions = resources.AsyncInstructionsResourceWithStreamingResponse(client.instructions) - self.generations = resources.AsyncGenerationsResourceWithStreamingResponse(client.generations) - self.prompts = resources.AsyncPromptsResourceWithStreamingResponse(client.prompts) - self.sql_generations = resources.AsyncSqlGenerationsResourceWithStreamingResponse(client.sql_generations) - self.nl_generations = resources.AsyncNlGenerationsResourceWithStreamingResponse(client.nl_generations) - self.table_descriptions = resources.AsyncTableDescriptionsResourceWithStreamingResponse( + self.finetunings = finetunings.AsyncFinetuningsResourceWithStreamingResponse(client.finetunings) + self.golden_sqls = golden_sqls.AsyncGoldenSqlsResourceWithStreamingResponse(client.golden_sqls) + self.instructions = instructions.AsyncInstructionsResourceWithStreamingResponse(client.instructions) + self.generations = generations.AsyncGenerationsResourceWithStreamingResponse(client.generations) + self.prompts = prompts.AsyncPromptsResourceWithStreamingResponse(client.prompts) + self.sql_generations = sql_generations.AsyncSqlGenerationsResourceWithStreamingResponse(client.sql_generations) + self.nl_generations = nl_generations.AsyncNlGenerationsResourceWithStreamingResponse(client.nl_generations) + self.table_descriptions = table_descriptions.AsyncTableDescriptionsResourceWithStreamingResponse( client.table_descriptions ) - self.heartbeat = resources.AsyncHeartbeatResourceWithStreamingResponse(client.heartbeat) - self.engine = resources.AsyncEngineResourceWithStreamingResponse(client.engine) + self.heartbeat = heartbeat.AsyncHeartbeatResourceWithStreamingResponse(client.heartbeat) + self.engine = engine.AsyncEngineResourceWithStreamingResponse(client.engine) Client = Dataherald diff --git a/tests/test_client.py b/tests/test_client.py index 0ab254b..e603042 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -345,11 +345,11 @@ def test_default_query_option(self) -> None: FinalRequestOptions( method="get", url="/foo", - params={"foo": "baz", "query_param": "overriden"}, + params={"foo": "baz", "query_param": "overridden"}, ) ) url = httpx.URL(request.url) - assert dict(url.params) == {"foo": "baz", "query_param": "overriden"} + assert dict(url.params) == {"foo": "baz", "query_param": "overridden"} def test_request_extra_json(self) -> None: request = self.client._build_request( @@ -1119,11 +1119,11 @@ def test_default_query_option(self) -> None: FinalRequestOptions( method="get", url="/foo", - params={"foo": "baz", "query_param": "overriden"}, + params={"foo": "baz", "query_param": "overridden"}, ) ) url = httpx.URL(request.url) - assert dict(url.params) == {"foo": "baz", "query_param": "overriden"} + assert dict(url.params) == {"foo": "baz", "query_param": "overridden"} def test_request_extra_json(self) -> None: request = self.client._build_request(