hanzoai/python-sdk
2
0
Fork 0
mirror of https://github.com/hanzoai/python-sdk.git synced 2026-10-23 20:23:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(hanzoai): regenerate client from unified OpenAPI spec (retire Stainless) (#45)

Browse Source 
Replace the Stainless-generated `hanzoai` client (188 legacy LLM-gateway
endpoints) with an openapi-generator `python` (urllib3 + pydantic v2)
client built from hanzoai/openapi `hanzo.yaml` — the full unified
api.hanzo.ai/v1 surface (493 API groups, 1710 models, all /v1 products).

- scripts/generate.sh: the one-way generator; emits only pkg/hanzoai
  (other pkg/hanzo-* packages untouched).
- pyproject: deps -> urllib3 / python-dateutil / pydantic>=2 /
  typing-extensions; version 2.2.3 -> 3.0.0 (breaking surface change).
- tests/: Stainless client tests replaced with a surface smoke test.
- .github/workflows/generate.yml: regenerate on openapi spec-update.
- Base URL https://api.hanzo.ai, Bearer hk- / JWT auth.

Verified: wheel hanzoai-3.0.0 builds, installs into a clean venv, and
`import hanzoai` + product API construction succeed.

Co-authored-by: Hanzo Dev <[email protected]>
This commit is contained in:
zeekay
2026-07-04 20:07:32 -07:00
committed by GitHub
co-authored by Hanzo Dev
parent 9155b4ccf3
commit 82df3bdcb3
2680 changed files with 801561 additions and 117735 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/audio/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/audio/test_speech.py
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestSpeech:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
speech = client.audio.speech.create()
assert_matches_type(object, speech, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.audio.speech.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
speech = response.parse()
assert_matches_type(object, speech, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.audio.speech.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
speech = response.parse()
assert_matches_type(object, speech, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncSpeech:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
speech = await async_client.audio.speech.create()
assert_matches_type(object, speech, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.audio.speech.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
speech = await response.parse()
assert_matches_type(object, speech, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.audio.speech.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
speech = await response.parse()
assert_matches_type(object, speech, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/audio/test_transcriptions.py
-83
View File
@@ -1,83 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestTranscriptions:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
transcription = client.audio.transcriptions.create(
file=b"raw file contents",
)
assert_matches_type(object, transcription, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.audio.transcriptions.with_raw_response.create(
file=b"raw file contents",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
transcription = response.parse()
assert_matches_type(object, transcription, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.audio.transcriptions.with_streaming_response.create(
file=b"raw file contents",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
transcription = response.parse()
assert_matches_type(object, transcription, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncTranscriptions:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
transcription = await async_client.audio.transcriptions.create(
file=b"raw file contents",
)
assert_matches_type(object, transcription, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.audio.transcriptions.with_raw_response.create(
file=b"raw file contents",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
transcription = await response.parse()
assert_matches_type(object, transcription, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.audio.transcriptions.with_streaming_response.create(
file=b"raw file contents",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
transcription = await response.parse()
assert_matches_type(object, transcription, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/batches/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/batches/test_cancel.py
-119
View File
@@ -1,119 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCancel:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_cancel(self, client: Hanzo) -> None:
cancel = client.batches.cancel.cancel(
batch_id="batch_id",
)
assert_matches_type(object, cancel, path=["response"])
@parametrize
def test_method_cancel_with_all_params(self, client: Hanzo) -> None:
cancel = client.batches.cancel.cancel(
batch_id="batch_id",
provider="provider",
)
assert_matches_type(object, cancel, path=["response"])
@parametrize
def test_raw_response_cancel(self, client: Hanzo) -> None:
response = client.batches.cancel.with_raw_response.cancel(
batch_id="batch_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cancel = response.parse()
assert_matches_type(object, cancel, path=["response"])
@parametrize
def test_streaming_response_cancel(self, client: Hanzo) -> None:
with client.batches.cancel.with_streaming_response.cancel(
batch_id="batch_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cancel = response.parse()
assert_matches_type(object, cancel, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_cancel(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `batch_id` but received ''",
):
client.batches.cancel.with_raw_response.cancel(
batch_id="",
)
class TestAsyncCancel:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_cancel(self, async_client: AsyncHanzo) -> None:
cancel = await async_client.batches.cancel.cancel(
batch_id="batch_id",
)
assert_matches_type(object, cancel, path=["response"])
@parametrize
async def test_method_cancel_with_all_params(self, async_client: AsyncHanzo) -> None:
cancel = await async_client.batches.cancel.cancel(
batch_id="batch_id",
provider="provider",
)
assert_matches_type(object, cancel, path=["response"])
@parametrize
async def test_raw_response_cancel(self, async_client: AsyncHanzo) -> None:
response = await async_client.batches.cancel.with_raw_response.cancel(
batch_id="batch_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cancel = await response.parse()
assert_matches_type(object, cancel, path=["response"])
@parametrize
async def test_streaming_response_cancel(self, async_client: AsyncHanzo) -> None:
async with async_client.batches.cancel.with_streaming_response.cancel(
batch_id="batch_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cancel = await response.parse()
assert_matches_type(object, cancel, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_cancel(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `batch_id` but received ''",
):
await async_client.batches.cancel.with_raw_response.cancel(
batch_id="",
)
tests/api_resources/cache/__init__.py
Vendored
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/cache/test_redis.py
Vendored
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestRedis:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_retrieve_info(self, client: Hanzo) -> None:
redi = client.cache.redis.retrieve_info()
assert_matches_type(object, redi, path=["response"])
@parametrize
def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
response = client.cache.redis.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
redi = response.parse()
assert_matches_type(object, redi, path=["response"])
@parametrize
def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
with client.cache.redis.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
redi = response.parse()
assert_matches_type(object, redi, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncRedis:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
redi = await async_client.cache.redis.retrieve_info()
assert_matches_type(object, redi, path=["response"])
@parametrize
async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
response = await async_client.cache.redis.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
redi = await response.parse()
assert_matches_type(object, redi, path=["response"])
@parametrize
async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
async with async_client.cache.redis.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
redi = await response.parse()
assert_matches_type(object, redi, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/chat/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/chat/test_completions.py
-85
View File
@@ -1,85 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCompletions:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
completion = client.chat.completions.create()
assert_matches_type(object, completion, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
completion = client.chat.completions.create(
model="model",
)
assert_matches_type(object, completion, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.chat.completions.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
completion = response.parse()
assert_matches_type(object, completion, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.chat.completions.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
completion = response.parse()
assert_matches_type(object, completion, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncCompletions:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
completion = await async_client.chat.completions.create()
assert_matches_type(object, completion, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
completion = await async_client.chat.completions.create(
model="model",
)
assert_matches_type(object, completion, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.chat.completions.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
completion = await response.parse()
assert_matches_type(object, completion, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.chat.completions.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
completion = await response.parse()
assert_matches_type(object, completion, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/config/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/config/test_pass_through_endpoint.py
-306
View File
@@ -1,306 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types.config import (
PassThroughEndpointResponse,
)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestPassThroughEndpoint:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
pass_through_endpoint = client.config.pass_through_endpoint.create(
headers={},
path="path",
target="target",
)
assert_matches_type(object, pass_through_endpoint, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.config.pass_through_endpoint.with_raw_response.create(
headers={},
path="path",
target="target",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = response.parse()
assert_matches_type(object, pass_through_endpoint, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.config.pass_through_endpoint.with_streaming_response.create(
headers={},
path="path",
target="target",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = response.parse()
assert_matches_type(object, pass_through_endpoint, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_update(self, client: Hanzo) -> None:
pass_through_endpoint = client.config.pass_through_endpoint.update(
"endpoint_id",
)
assert_matches_type(object, pass_through_endpoint, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.config.pass_through_endpoint.with_raw_response.update(
"endpoint_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = response.parse()
assert_matches_type(object, pass_through_endpoint, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.config.pass_through_endpoint.with_streaming_response.update(
"endpoint_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = response.parse()
assert_matches_type(object, pass_through_endpoint, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint_id` but received ''",
):
client.config.pass_through_endpoint.with_raw_response.update(
"",
)
@parametrize
def test_method_list(self, client: Hanzo) -> None:
pass_through_endpoint = client.config.pass_through_endpoint.list()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
pass_through_endpoint = client.config.pass_through_endpoint.list(
endpoint_id="endpoint_id",
)
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.config.pass_through_endpoint.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = response.parse()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.config.pass_through_endpoint.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = response.parse()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
pass_through_endpoint = client.config.pass_through_endpoint.delete(
endpoint_id="endpoint_id",
)
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.config.pass_through_endpoint.with_raw_response.delete(
endpoint_id="endpoint_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = response.parse()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.config.pass_through_endpoint.with_streaming_response.delete(
endpoint_id="endpoint_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = response.parse()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncPassThroughEndpoint:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
pass_through_endpoint = await async_client.config.pass_through_endpoint.create(
headers={},
path="path",
target="target",
)
assert_matches_type(object, pass_through_endpoint, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.config.pass_through_endpoint.with_raw_response.create(
headers={},
path="path",
target="target",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = await response.parse()
assert_matches_type(object, pass_through_endpoint, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.config.pass_through_endpoint.with_streaming_response.create(
headers={},
path="path",
target="target",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = await response.parse()
assert_matches_type(object, pass_through_endpoint, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
pass_through_endpoint = await async_client.config.pass_through_endpoint.update(
"endpoint_id",
)
assert_matches_type(object, pass_through_endpoint, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.config.pass_through_endpoint.with_raw_response.update(
"endpoint_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = await response.parse()
assert_matches_type(object, pass_through_endpoint, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.config.pass_through_endpoint.with_streaming_response.update(
"endpoint_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = await response.parse()
assert_matches_type(object, pass_through_endpoint, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint_id` but received ''",
):
await async_client.config.pass_through_endpoint.with_raw_response.update(
"",
)
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
pass_through_endpoint = await async_client.config.pass_through_endpoint.list()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
pass_through_endpoint = await async_client.config.pass_through_endpoint.list(
endpoint_id="endpoint_id",
)
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.config.pass_through_endpoint.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = await response.parse()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.config.pass_through_endpoint.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = await response.parse()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
pass_through_endpoint = await async_client.config.pass_through_endpoint.delete(
endpoint_id="endpoint_id",
)
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.config.pass_through_endpoint.with_raw_response.delete(
endpoint_id="endpoint_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = await response.parse()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.config.pass_through_endpoint.with_streaming_response.delete(
endpoint_id="endpoint_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
pass_through_endpoint = await response.parse()
assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/engines/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/engines/test_chat.py
-97
View File
@@ -1,97 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestChat:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_complete(self, client: Hanzo) -> None:
chat = client.engines.chat.complete(
"model",
)
assert_matches_type(object, chat, path=["response"])
@parametrize
def test_raw_response_complete(self, client: Hanzo) -> None:
response = client.engines.chat.with_raw_response.complete(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
chat = response.parse()
assert_matches_type(object, chat, path=["response"])
@parametrize
def test_streaming_response_complete(self, client: Hanzo) -> None:
with client.engines.chat.with_streaming_response.complete(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
chat = response.parse()
assert_matches_type(object, chat, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_complete(self, client: Hanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
client.engines.chat.with_raw_response.complete(
"",
)
class TestAsyncChat:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_complete(self, async_client: AsyncHanzo) -> None:
chat = await async_client.engines.chat.complete(
"model",
)
assert_matches_type(object, chat, path=["response"])
@parametrize
async def test_raw_response_complete(self, async_client: AsyncHanzo) -> None:
response = await async_client.engines.chat.with_raw_response.complete(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
chat = await response.parse()
assert_matches_type(object, chat, path=["response"])
@parametrize
async def test_streaming_response_complete(self, async_client: AsyncHanzo) -> None:
async with async_client.engines.chat.with_streaming_response.complete(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
chat = await response.parse()
assert_matches_type(object, chat, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_complete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
await async_client.engines.chat.with_raw_response.complete(
"",
)
tests/api_resources/files/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/files/test_content.py
-126
View File
@@ -1,126 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import TYPE_CHECKING, Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
if TYPE_CHECKING:
from _pytest.fixtures import FixtureRequest
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestContent:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_retrieve(self, client: Hanzo, request: FixtureRequest) -> None:
content = client.files.content.retrieve(
file_id="file_id",
provider="provider",
)
assert_matches_type(object, content, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo, request: FixtureRequest) -> None:
response = client.files.content.with_raw_response.retrieve(
file_id="file_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
content = response.parse()
assert_matches_type(object, content, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo, request: FixtureRequest) -> None:
with client.files.content.with_streaming_response.retrieve(
file_id="file_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
content = response.parse()
assert_matches_type(object, content, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.files.content.with_raw_response.retrieve(
file_id="file_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `file_id` but received ''",
):
client.files.content.with_raw_response.retrieve(
file_id="",
provider="provider",
)
class TestAsyncContent:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo, request: FixtureRequest) -> None:
content = await async_client.files.content.retrieve(
file_id="file_id",
provider="provider",
)
assert_matches_type(object, content, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo, request: FixtureRequest) -> None:
response = await async_client.files.content.with_raw_response.retrieve(
file_id="file_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
content = await response.parse()
assert_matches_type(object, content, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo, request: FixtureRequest) -> None:
async with async_client.files.content.with_streaming_response.retrieve(
file_id="file_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
content = await response.parse()
assert content == "file content" or isinstance(content, (str, bytes, object))
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.files.content.with_raw_response.retrieve(
file_id="file_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `file_id` but received ''",
):
await async_client.files.content.with_raw_response.retrieve(
file_id="",
provider="provider",
)
tests/api_resources/fine_tuning/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/fine_tuning/jobs/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/fine_tuning/jobs/test_cancel.py
-103
View File
@@ -1,103 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCancel:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
cancel = client.fine_tuning.jobs.cancel.create(
"fine_tuning_job_id",
)
assert_matches_type(object, cancel, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.fine_tuning.jobs.cancel.with_raw_response.create(
"fine_tuning_job_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cancel = response.parse()
assert_matches_type(object, cancel, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.fine_tuning.jobs.cancel.with_streaming_response.create(
"fine_tuning_job_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cancel = response.parse()
assert_matches_type(object, cancel, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''",
):
client.fine_tuning.jobs.cancel.with_raw_response.create(
"",
)
class TestAsyncCancel:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
cancel = await async_client.fine_tuning.jobs.cancel.create(
"fine_tuning_job_id",
)
assert_matches_type(object, cancel, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.fine_tuning.jobs.cancel.with_raw_response.create(
"fine_tuning_job_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cancel = await response.parse()
assert_matches_type(object, cancel, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.fine_tuning.jobs.cancel.with_streaming_response.create(
"fine_tuning_job_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cancel = await response.parse()
assert_matches_type(object, cancel, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''",
):
await async_client.fine_tuning.jobs.cancel.with_raw_response.create(
"",
)
tests/api_resources/fine_tuning/test_jobs.py
-301
View File
@@ -1,301 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestJobs:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
job = client.fine_tuning.jobs.create(
custom_llm_provider="openai",
model="model",
training_file="training_file",
)
assert_matches_type(object, job, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
job = client.fine_tuning.jobs.create(
custom_llm_provider="openai",
model="model",
training_file="training_file",
hyperparameters={
"batch_size": "string",
"learning_rate_multiplier": "string",
"n_epochs": "string",
},
integrations=["string"],
seed=0,
suffix="suffix",
validation_file="validation_file",
)
assert_matches_type(object, job, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.fine_tuning.jobs.with_raw_response.create(
custom_llm_provider="openai",
model="model",
training_file="training_file",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = response.parse()
assert_matches_type(object, job, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.fine_tuning.jobs.with_streaming_response.create(
custom_llm_provider="openai",
model="model",
training_file="training_file",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = response.parse()
assert_matches_type(object, job, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
job = client.fine_tuning.jobs.retrieve(
fine_tuning_job_id="fine_tuning_job_id",
custom_llm_provider="openai",
)
assert_matches_type(object, job, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.fine_tuning.jobs.with_raw_response.retrieve(
fine_tuning_job_id="fine_tuning_job_id",
custom_llm_provider="openai",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = response.parse()
assert_matches_type(object, job, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.fine_tuning.jobs.with_streaming_response.retrieve(
fine_tuning_job_id="fine_tuning_job_id",
custom_llm_provider="openai",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = response.parse()
assert_matches_type(object, job, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''",
):
client.fine_tuning.jobs.with_raw_response.retrieve(
fine_tuning_job_id="",
custom_llm_provider="openai",
)
@parametrize
def test_method_list(self, client: Hanzo) -> None:
job = client.fine_tuning.jobs.list(
custom_llm_provider="openai",
)
assert_matches_type(object, job, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
job = client.fine_tuning.jobs.list(
custom_llm_provider="openai",
after="after",
limit=0,
)
assert_matches_type(object, job, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.fine_tuning.jobs.with_raw_response.list(
custom_llm_provider="openai",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = response.parse()
assert_matches_type(object, job, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.fine_tuning.jobs.with_streaming_response.list(
custom_llm_provider="openai",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = response.parse()
assert_matches_type(object, job, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncJobs:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
job = await async_client.fine_tuning.jobs.create(
custom_llm_provider="openai",
model="model",
training_file="training_file",
)
assert_matches_type(object, job, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
job = await async_client.fine_tuning.jobs.create(
custom_llm_provider="openai",
model="model",
training_file="training_file",
hyperparameters={
"batch_size": "string",
"learning_rate_multiplier": "string",
"n_epochs": "string",
},
integrations=["string"],
seed=0,
suffix="suffix",
validation_file="validation_file",
)
assert_matches_type(object, job, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.fine_tuning.jobs.with_raw_response.create(
custom_llm_provider="openai",
model="model",
training_file="training_file",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = await response.parse()
assert_matches_type(object, job, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.fine_tuning.jobs.with_streaming_response.create(
custom_llm_provider="openai",
model="model",
training_file="training_file",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = await response.parse()
assert_matches_type(object, job, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
job = await async_client.fine_tuning.jobs.retrieve(
fine_tuning_job_id="fine_tuning_job_id",
custom_llm_provider="openai",
)
assert_matches_type(object, job, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.fine_tuning.jobs.with_raw_response.retrieve(
fine_tuning_job_id="fine_tuning_job_id",
custom_llm_provider="openai",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = await response.parse()
assert_matches_type(object, job, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.fine_tuning.jobs.with_streaming_response.retrieve(
fine_tuning_job_id="fine_tuning_job_id",
custom_llm_provider="openai",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = await response.parse()
assert_matches_type(object, job, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''",
):
await async_client.fine_tuning.jobs.with_raw_response.retrieve(
fine_tuning_job_id="",
custom_llm_provider="openai",
)
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
job = await async_client.fine_tuning.jobs.list(
custom_llm_provider="openai",
)
assert_matches_type(object, job, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
job = await async_client.fine_tuning.jobs.list(
custom_llm_provider="openai",
after="after",
limit=0,
)
assert_matches_type(object, job, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.fine_tuning.jobs.with_raw_response.list(
custom_llm_provider="openai",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = await response.parse()
assert_matches_type(object, job, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.fine_tuning.jobs.with_streaming_response.list(
custom_llm_provider="openai",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
job = await response.parse()
assert_matches_type(object, job, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/global_/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/global_/test_spend.py
-219
View File
@@ -1,219 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types.global_ import (
SpendListTagsResponse,
SpendRetrieveReportResponse,
)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestSpend:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_list_tags(self, client: Hanzo) -> None:
spend = client.global_.spend.list_tags()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
def test_method_list_tags_with_all_params(self, client: Hanzo) -> None:
spend = client.global_.spend.list_tags(
end_date="end_date",
start_date="start_date",
tags="tags",
)
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
def test_raw_response_list_tags(self, client: Hanzo) -> None:
response = client.global_.spend.with_raw_response.list_tags()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
def test_streaming_response_list_tags(self, client: Hanzo) -> None:
with client.global_.spend.with_streaming_response.list_tags() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_reset(self, client: Hanzo) -> None:
spend = client.global_.spend.reset()
assert_matches_type(object, spend, path=["response"])
@parametrize
def test_raw_response_reset(self, client: Hanzo) -> None:
response = client.global_.spend.with_raw_response.reset()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(object, spend, path=["response"])
@parametrize
def test_streaming_response_reset(self, client: Hanzo) -> None:
with client.global_.spend.with_streaming_response.reset() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(object, spend, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_retrieve_report(self, client: Hanzo) -> None:
spend = client.global_.spend.retrieve_report()
assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
@parametrize
def test_method_retrieve_report_with_all_params(self, client: Hanzo) -> None:
spend = client.global_.spend.retrieve_report(
api_key="api_key",
customer_id="customer_id",
end_date="end_date",
group_by="team",
internal_user_id="internal_user_id",
start_date="start_date",
team_id="team_id",
)
assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
@parametrize
def test_raw_response_retrieve_report(self, client: Hanzo) -> None:
response = client.global_.spend.with_raw_response.retrieve_report()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
@parametrize
def test_streaming_response_retrieve_report(self, client: Hanzo) -> None:
with client.global_.spend.with_streaming_response.retrieve_report() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncSpend:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_list_tags(self, async_client: AsyncHanzo) -> None:
spend = await async_client.global_.spend.list_tags()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
async def test_method_list_tags_with_all_params(self, async_client: AsyncHanzo) -> None:
spend = await async_client.global_.spend.list_tags(
end_date="end_date",
start_date="start_date",
tags="tags",
)
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
async def test_raw_response_list_tags(self, async_client: AsyncHanzo) -> None:
response = await async_client.global_.spend.with_raw_response.list_tags()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
async def test_streaming_response_list_tags(self, async_client: AsyncHanzo) -> None:
async with async_client.global_.spend.with_streaming_response.list_tags() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_reset(self, async_client: AsyncHanzo) -> None:
spend = await async_client.global_.spend.reset()
assert_matches_type(object, spend, path=["response"])
@parametrize
async def test_raw_response_reset(self, async_client: AsyncHanzo) -> None:
response = await async_client.global_.spend.with_raw_response.reset()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(object, spend, path=["response"])
@parametrize
async def test_streaming_response_reset(self, async_client: AsyncHanzo) -> None:
async with async_client.global_.spend.with_streaming_response.reset() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(object, spend, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_retrieve_report(self, async_client: AsyncHanzo) -> None:
spend = await async_client.global_.spend.retrieve_report()
assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
@parametrize
async def test_method_retrieve_report_with_all_params(self, async_client: AsyncHanzo) -> None:
spend = await async_client.global_.spend.retrieve_report(
api_key="api_key",
customer_id="customer_id",
end_date="end_date",
group_by="team",
internal_user_id="internal_user_id",
start_date="start_date",
team_id="team_id",
)
assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
@parametrize
async def test_raw_response_retrieve_report(self, async_client: AsyncHanzo) -> None:
response = await async_client.global_.spend.with_raw_response.retrieve_report()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
@parametrize
async def test_streaming_response_retrieve_report(self, async_client: AsyncHanzo) -> None:
async with async_client.global_.spend.with_streaming_response.retrieve_report() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/images/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/images/test_generations.py
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestGenerations:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
generation = client.images.generations.create()
assert_matches_type(object, generation, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.images.generations.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
generation = response.parse()
assert_matches_type(object, generation, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.images.generations.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
generation = response.parse()
assert_matches_type(object, generation, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncGenerations:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
generation = await async_client.images.generations.create()
assert_matches_type(object, generation, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.images.generations.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
generation = await response.parse()
assert_matches_type(object, generation, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.images.generations.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
generation = await response.parse()
assert_matches_type(object, generation, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/key/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/model/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/model/test_info.py
-85
View File
@@ -1,85 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestInfo:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_list(self, client: Hanzo) -> None:
info = client.model.info.list()
assert_matches_type(object, info, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
info = client.model.info.list(
hanzo_model_id="hanzo_model_id",
)
assert_matches_type(object, info, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.model.info.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = response.parse()
assert_matches_type(object, info, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.model.info.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = response.parse()
assert_matches_type(object, info, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncInfo:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
info = await async_client.model.info.list()
assert_matches_type(object, info, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
info = await async_client.model.info.list(
hanzo_model_id="hanzo_model_id",
)
assert_matches_type(object, info, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.model.info.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = await response.parse()
assert_matches_type(object, info, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.model.info.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = await response.parse()
assert_matches_type(object, info, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/model/test_update.py
-364
View File
@@ -1,364 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai._utils import parse_datetime
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestUpdate:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_full(self, client: Hanzo) -> None:
update = client.model.update.full()
assert_matches_type(object, update, path=["response"])
@parametrize
def test_method_full_with_all_params(self, client: Hanzo) -> None:
update = client.model.update.full(
hanzo_params={
"api_base": "api_base",
"api_key": "api_key",
"api_version": "api_version",
"aws_access_key_id": "aws_access_key_id",
"aws_region_name": "aws_region_name",
"aws_secret_access_key": "aws_secret_access_key",
"budget_duration": "budget_duration",
"configurable_clientside_auth_params": ["string"],
"custom_llm_provider": "custom_llm_provider",
"input_cost_per_second": 0,
"input_cost_per_token": 0,
"hanzo_trace_id": "hanzo_trace_id",
"max_budget": 0,
"max_file_size_mb": 0,
"max_retries": 0,
"merge_reasoning_content_in_choices": True,
"model": "model",
"model_info": {},
"organization": "organization",
"output_cost_per_second": 0,
"output_cost_per_token": 0,
"region_name": "region_name",
"rpm": 0,
"stream_timeout": 0,
"timeout": 0,
"tpm": 0,
"use_in_pass_through": True,
"vertex_credentials": "string",
"vertex_location": "vertex_location",
"vertex_project": "vertex_project",
"watsonx_region_name": "watsonx_region_name",
},
model_info={
"id": "id",
"base_model": "base_model",
"created_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"created_by": "created_by",
"db_model": True,
"team_id": "team_id",
"team_public_model_name": "team_public_model_name",
"tier": "free",
"updated_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"updated_by": "updated_by",
},
model_name="model_name",
)
assert_matches_type(object, update, path=["response"])
@parametrize
def test_raw_response_full(self, client: Hanzo) -> None:
response = client.model.update.with_raw_response.full()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
update = response.parse()
assert_matches_type(object, update, path=["response"])
@parametrize
def test_streaming_response_full(self, client: Hanzo) -> None:
with client.model.update.with_streaming_response.full() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
update = response.parse()
assert_matches_type(object, update, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_partial(self, client: Hanzo) -> None:
update = client.model.update.partial(
model_id="model_id",
)
assert_matches_type(object, update, path=["response"])
@parametrize
def test_method_partial_with_all_params(self, client: Hanzo) -> None:
update = client.model.update.partial(
model_id="model_id",
hanzo_params={
"api_base": "api_base",
"api_key": "api_key",
"api_version": "api_version",
"aws_access_key_id": "aws_access_key_id",
"aws_region_name": "aws_region_name",
"aws_secret_access_key": "aws_secret_access_key",
"budget_duration": "budget_duration",
"configurable_clientside_auth_params": ["string"],
"custom_llm_provider": "custom_llm_provider",
"input_cost_per_second": 0,
"input_cost_per_token": 0,
"hanzo_trace_id": "hanzo_trace_id",
"max_budget": 0,
"max_file_size_mb": 0,
"max_retries": 0,
"merge_reasoning_content_in_choices": True,
"model": "model",
"model_info": {},
"organization": "organization",
"output_cost_per_second": 0,
"output_cost_per_token": 0,
"region_name": "region_name",
"rpm": 0,
"stream_timeout": 0,
"timeout": 0,
"tpm": 0,
"use_in_pass_through": True,
"vertex_credentials": "string",
"vertex_location": "vertex_location",
"vertex_project": "vertex_project",
"watsonx_region_name": "watsonx_region_name",
},
model_info={
"id": "id",
"base_model": "base_model",
"created_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"created_by": "created_by",
"db_model": True,
"team_id": "team_id",
"team_public_model_name": "team_public_model_name",
"tier": "free",
"updated_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"updated_by": "updated_by",
},
model_name="model_name",
)
assert_matches_type(object, update, path=["response"])
@parametrize
def test_raw_response_partial(self, client: Hanzo) -> None:
response = client.model.update.with_raw_response.partial(
model_id="model_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
update = response.parse()
assert_matches_type(object, update, path=["response"])
@parametrize
def test_streaming_response_partial(self, client: Hanzo) -> None:
with client.model.update.with_streaming_response.partial(
model_id="model_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
update = response.parse()
assert_matches_type(object, update, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_partial(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `model_id` but received ''",
):
client.model.update.with_raw_response.partial(
model_id="",
)
class TestAsyncUpdate:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_full(self, async_client: AsyncHanzo) -> None:
update = await async_client.model.update.full()
assert_matches_type(object, update, path=["response"])
@parametrize
async def test_method_full_with_all_params(self, async_client: AsyncHanzo) -> None:
update = await async_client.model.update.full(
hanzo_params={
"api_base": "api_base",
"api_key": "api_key",
"api_version": "api_version",
"aws_access_key_id": "aws_access_key_id",
"aws_region_name": "aws_region_name",
"aws_secret_access_key": "aws_secret_access_key",
"budget_duration": "budget_duration",
"configurable_clientside_auth_params": ["string"],
"custom_llm_provider": "custom_llm_provider",
"input_cost_per_second": 0,
"input_cost_per_token": 0,
"hanzo_trace_id": "hanzo_trace_id",
"max_budget": 0,
"max_file_size_mb": 0,
"max_retries": 0,
"merge_reasoning_content_in_choices": True,
"model": "model",
"model_info": {},
"organization": "organization",
"output_cost_per_second": 0,
"output_cost_per_token": 0,
"region_name": "region_name",
"rpm": 0,
"stream_timeout": 0,
"timeout": 0,
"tpm": 0,
"use_in_pass_through": True,
"vertex_credentials": "string",
"vertex_location": "vertex_location",
"vertex_project": "vertex_project",
"watsonx_region_name": "watsonx_region_name",
},
model_info={
"id": "id",
"base_model": "base_model",
"created_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"created_by": "created_by",
"db_model": True,
"team_id": "team_id",
"team_public_model_name": "team_public_model_name",
"tier": "free",
"updated_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"updated_by": "updated_by",
},
model_name="model_name",
)
assert_matches_type(object, update, path=["response"])
@parametrize
async def test_raw_response_full(self, async_client: AsyncHanzo) -> None:
response = await async_client.model.update.with_raw_response.full()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
update = await response.parse()
assert_matches_type(object, update, path=["response"])
@parametrize
async def test_streaming_response_full(self, async_client: AsyncHanzo) -> None:
async with async_client.model.update.with_streaming_response.full() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
update = await response.parse()
assert_matches_type(object, update, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_partial(self, async_client: AsyncHanzo) -> None:
update = await async_client.model.update.partial(
model_id="model_id",
)
assert_matches_type(object, update, path=["response"])
@parametrize
async def test_method_partial_with_all_params(self, async_client: AsyncHanzo) -> None:
update = await async_client.model.update.partial(
model_id="model_id",
hanzo_params={
"api_base": "api_base",
"api_key": "api_key",
"api_version": "api_version",
"aws_access_key_id": "aws_access_key_id",
"aws_region_name": "aws_region_name",
"aws_secret_access_key": "aws_secret_access_key",
"budget_duration": "budget_duration",
"configurable_clientside_auth_params": ["string"],
"custom_llm_provider": "custom_llm_provider",
"input_cost_per_second": 0,
"input_cost_per_token": 0,
"hanzo_trace_id": "hanzo_trace_id",
"max_budget": 0,
"max_file_size_mb": 0,
"max_retries": 0,
"merge_reasoning_content_in_choices": True,
"model": "model",
"model_info": {},
"organization": "organization",
"output_cost_per_second": 0,
"output_cost_per_token": 0,
"region_name": "region_name",
"rpm": 0,
"stream_timeout": 0,
"timeout": 0,
"tpm": 0,
"use_in_pass_through": True,
"vertex_credentials": "string",
"vertex_location": "vertex_location",
"vertex_project": "vertex_project",
"watsonx_region_name": "watsonx_region_name",
},
model_info={
"id": "id",
"base_model": "base_model",
"created_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"created_by": "created_by",
"db_model": True,
"team_id": "team_id",
"team_public_model_name": "team_public_model_name",
"tier": "free",
"updated_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"updated_by": "updated_by",
},
model_name="model_name",
)
assert_matches_type(object, update, path=["response"])
@parametrize
async def test_raw_response_partial(self, async_client: AsyncHanzo) -> None:
response = await async_client.model.update.with_raw_response.partial(
model_id="model_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
update = await response.parse()
assert_matches_type(object, update, path=["response"])
@parametrize
async def test_streaming_response_partial(self, async_client: AsyncHanzo) -> None:
async with async_client.model.update.with_streaming_response.partial(
model_id="model_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
update = await response.parse()
assert_matches_type(object, update, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_partial(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `model_id` but received ''",
):
await async_client.model.update.with_raw_response.partial(
model_id="",
)
tests/api_resources/openai/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/openai/deployments/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/openai/deployments/test_chat.py
-97
View File
@@ -1,97 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestChat:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_complete(self, client: Hanzo) -> None:
chat = client.openai.deployments.chat.complete(
"model",
)
assert_matches_type(object, chat, path=["response"])
@parametrize
def test_raw_response_complete(self, client: Hanzo) -> None:
response = client.openai.deployments.chat.with_raw_response.complete(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
chat = response.parse()
assert_matches_type(object, chat, path=["response"])
@parametrize
def test_streaming_response_complete(self, client: Hanzo) -> None:
with client.openai.deployments.chat.with_streaming_response.complete(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
chat = response.parse()
assert_matches_type(object, chat, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_complete(self, client: Hanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
client.openai.deployments.chat.with_raw_response.complete(
"",
)
class TestAsyncChat:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_complete(self, async_client: AsyncHanzo) -> None:
chat = await async_client.openai.deployments.chat.complete(
"model",
)
assert_matches_type(object, chat, path=["response"])
@parametrize
async def test_raw_response_complete(self, async_client: AsyncHanzo) -> None:
response = await async_client.openai.deployments.chat.with_raw_response.complete(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
chat = await response.parse()
assert_matches_type(object, chat, path=["response"])
@parametrize
async def test_streaming_response_complete(self, async_client: AsyncHanzo) -> None:
async with async_client.openai.deployments.chat.with_streaming_response.complete(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
chat = await response.parse()
assert_matches_type(object, chat, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_complete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
await async_client.openai.deployments.chat.with_raw_response.complete(
"",
)
tests/api_resources/openai/test_deployments.py
-173
View File
@@ -1,173 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestDeployments:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_complete(self, client: Hanzo) -> None:
deployment = client.openai.deployments.complete(
"model",
)
assert_matches_type(object, deployment, path=["response"])
@parametrize
def test_raw_response_complete(self, client: Hanzo) -> None:
response = client.openai.deployments.with_raw_response.complete(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
deployment = response.parse()
assert_matches_type(object, deployment, path=["response"])
@parametrize
def test_streaming_response_complete(self, client: Hanzo) -> None:
with client.openai.deployments.with_streaming_response.complete(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
deployment = response.parse()
assert_matches_type(object, deployment, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_complete(self, client: Hanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
client.openai.deployments.with_raw_response.complete(
"",
)
@parametrize
def test_method_embed(self, client: Hanzo) -> None:
deployment = client.openai.deployments.embed(
"model",
)
assert_matches_type(object, deployment, path=["response"])
@parametrize
def test_raw_response_embed(self, client: Hanzo) -> None:
response = client.openai.deployments.with_raw_response.embed(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
deployment = response.parse()
assert_matches_type(object, deployment, path=["response"])
@parametrize
def test_streaming_response_embed(self, client: Hanzo) -> None:
with client.openai.deployments.with_streaming_response.embed(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
deployment = response.parse()
assert_matches_type(object, deployment, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_embed(self, client: Hanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
client.openai.deployments.with_raw_response.embed(
"",
)
class TestAsyncDeployments:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_complete(self, async_client: AsyncHanzo) -> None:
deployment = await async_client.openai.deployments.complete(
"model",
)
assert_matches_type(object, deployment, path=["response"])
@parametrize
async def test_raw_response_complete(self, async_client: AsyncHanzo) -> None:
response = await async_client.openai.deployments.with_raw_response.complete(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
deployment = await response.parse()
assert_matches_type(object, deployment, path=["response"])
@parametrize
async def test_streaming_response_complete(self, async_client: AsyncHanzo) -> None:
async with async_client.openai.deployments.with_streaming_response.complete(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
deployment = await response.parse()
assert_matches_type(object, deployment, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_complete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
await async_client.openai.deployments.with_raw_response.complete(
"",
)
@parametrize
async def test_method_embed(self, async_client: AsyncHanzo) -> None:
deployment = await async_client.openai.deployments.embed(
"model",
)
assert_matches_type(object, deployment, path=["response"])
@parametrize
async def test_raw_response_embed(self, async_client: AsyncHanzo) -> None:
response = await async_client.openai.deployments.with_raw_response.embed(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
deployment = await response.parse()
assert_matches_type(object, deployment, path=["response"])
@parametrize
async def test_streaming_response_embed(self, async_client: AsyncHanzo) -> None:
async with async_client.openai.deployments.with_streaming_response.embed(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
deployment = await response.parse()
assert_matches_type(object, deployment, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_embed(self, async_client: AsyncHanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
await async_client.openai.deployments.with_raw_response.embed(
"",
)
tests/api_resources/organization/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/organization/test_info.py
-146
View File
@@ -1,146 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types.organization import InfoRetrieveResponse
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestInfo:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
info = client.organization.info.retrieve(
organization_id="organization_id",
)
assert_matches_type(InfoRetrieveResponse, info, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.organization.info.with_raw_response.retrieve(
organization_id="organization_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = response.parse()
assert_matches_type(InfoRetrieveResponse, info, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.organization.info.with_streaming_response.retrieve(
organization_id="organization_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = response.parse()
assert_matches_type(InfoRetrieveResponse, info, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_deprecated(self, client: Hanzo) -> None:
info = client.organization.info.deprecated(
organizations=["string"],
)
assert_matches_type(object, info, path=["response"])
@parametrize
def test_raw_response_deprecated(self, client: Hanzo) -> None:
response = client.organization.info.with_raw_response.deprecated(
organizations=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = response.parse()
assert_matches_type(object, info, path=["response"])
@parametrize
def test_streaming_response_deprecated(self, client: Hanzo) -> None:
with client.organization.info.with_streaming_response.deprecated(
organizations=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = response.parse()
assert_matches_type(object, info, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncInfo:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
info = await async_client.organization.info.retrieve(
organization_id="organization_id",
)
assert_matches_type(InfoRetrieveResponse, info, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.info.with_raw_response.retrieve(
organization_id="organization_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = await response.parse()
assert_matches_type(InfoRetrieveResponse, info, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.info.with_streaming_response.retrieve(
organization_id="organization_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = await response.parse()
assert_matches_type(InfoRetrieveResponse, info, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_deprecated(self, async_client: AsyncHanzo) -> None:
info = await async_client.organization.info.deprecated(
organizations=["string"],
)
assert_matches_type(object, info, path=["response"])
@parametrize
async def test_raw_response_deprecated(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.info.with_raw_response.deprecated(
organizations=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = await response.parse()
assert_matches_type(object, info, path=["response"])
@parametrize
async def test_streaming_response_deprecated(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.info.with_streaming_response.deprecated(
organizations=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
info = await response.parse()
assert_matches_type(object, info, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/responses/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/responses/test_input_items.py
-103
View File
@@ -1,103 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestInputItems:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_list(self, client: Hanzo) -> None:
input_item = client.responses.input_items.list(
"response_id",
)
assert_matches_type(object, input_item, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.responses.input_items.with_raw_response.list(
"response_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
input_item = response.parse()
assert_matches_type(object, input_item, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.responses.input_items.with_streaming_response.list(
"response_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
input_item = response.parse()
assert_matches_type(object, input_item, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_list(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `response_id` but received ''",
):
client.responses.input_items.with_raw_response.list(
"",
)
class TestAsyncInputItems:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
input_item = await async_client.responses.input_items.list(
"response_id",
)
assert_matches_type(object, input_item, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.responses.input_items.with_raw_response.list(
"response_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
input_item = await response.parse()
assert_matches_type(object, input_item, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.responses.input_items.with_streaming_response.list(
"response_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
input_item = await response.parse()
assert_matches_type(object, input_item, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_list(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `response_id` but received ''",
):
await async_client.responses.input_items.with_raw_response.list(
"",
)
tests/api_resources/team/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/team/test_callback.py
-223
View File
@@ -1,223 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCallback:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
callback = client.team.callback.retrieve(
"team_id",
)
assert_matches_type(object, callback, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.team.callback.with_raw_response.retrieve(
"team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
callback = response.parse()
assert_matches_type(object, callback, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.team.callback.with_streaming_response.retrieve(
"team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
callback = response.parse()
assert_matches_type(object, callback, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `team_id` but received ''",
):
client.team.callback.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_add(self, client: Hanzo) -> None:
callback = client.team.callback.add(
team_id="team_id",
callback_name="callback_name",
callback_vars={"foo": "string"},
)
assert_matches_type(object, callback, path=["response"])
@parametrize
def test_method_add_with_all_params(self, client: Hanzo) -> None:
callback = client.team.callback.add(
team_id="team_id",
callback_name="callback_name",
callback_vars={"foo": "string"},
callback_type="success",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, callback, path=["response"])
@parametrize
def test_raw_response_add(self, client: Hanzo) -> None:
response = client.team.callback.with_raw_response.add(
team_id="team_id",
callback_name="callback_name",
callback_vars={"foo": "string"},
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
callback = response.parse()
assert_matches_type(object, callback, path=["response"])
@parametrize
def test_streaming_response_add(self, client: Hanzo) -> None:
with client.team.callback.with_streaming_response.add(
team_id="team_id",
callback_name="callback_name",
callback_vars={"foo": "string"},
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
callback = response.parse()
assert_matches_type(object, callback, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_add(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `team_id` but received ''",
):
client.team.callback.with_raw_response.add(
team_id="",
callback_name="callback_name",
callback_vars={"foo": "string"},
)
class TestAsyncCallback:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
callback = await async_client.team.callback.retrieve(
"team_id",
)
assert_matches_type(object, callback, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.callback.with_raw_response.retrieve(
"team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
callback = await response.parse()
assert_matches_type(object, callback, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.team.callback.with_streaming_response.retrieve(
"team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
callback = await response.parse()
assert_matches_type(object, callback, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `team_id` but received ''",
):
await async_client.team.callback.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_add(self, async_client: AsyncHanzo) -> None:
callback = await async_client.team.callback.add(
team_id="team_id",
callback_name="callback_name",
callback_vars={"foo": "string"},
)
assert_matches_type(object, callback, path=["response"])
@parametrize
async def test_method_add_with_all_params(self, async_client: AsyncHanzo) -> None:
callback = await async_client.team.callback.add(
team_id="team_id",
callback_name="callback_name",
callback_vars={"foo": "string"},
callback_type="success",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, callback, path=["response"])
@parametrize
async def test_raw_response_add(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.callback.with_raw_response.add(
team_id="team_id",
callback_name="callback_name",
callback_vars={"foo": "string"},
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
callback = await response.parse()
assert_matches_type(object, callback, path=["response"])
@parametrize
async def test_streaming_response_add(self, async_client: AsyncHanzo) -> None:
async with async_client.team.callback.with_streaming_response.add(
team_id="team_id",
callback_name="callback_name",
callback_vars={"foo": "string"},
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
callback = await response.parse()
assert_matches_type(object, callback, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_add(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `team_id` but received ''",
):
await async_client.team.callback.with_raw_response.add(
team_id="",
callback_name="callback_name",
callback_vars={"foo": "string"},
)
tests/api_resources/team/test_model.py
-157
View File
@@ -1,157 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestModel:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_add(self, client: Hanzo) -> None:
model = client.team.model.add(
models=["string"],
team_id="team_id",
)
assert_matches_type(object, model, path=["response"])
@parametrize
def test_raw_response_add(self, client: Hanzo) -> None:
response = client.team.model.with_raw_response.add(
models=["string"],
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
def test_streaming_response_add(self, client: Hanzo) -> None:
with client.team.model.with_streaming_response.add(
models=["string"],
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_remove(self, client: Hanzo) -> None:
model = client.team.model.remove(
models=["string"],
team_id="team_id",
)
assert_matches_type(object, model, path=["response"])
@parametrize
def test_raw_response_remove(self, client: Hanzo) -> None:
response = client.team.model.with_raw_response.remove(
models=["string"],
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
def test_streaming_response_remove(self, client: Hanzo) -> None:
with client.team.model.with_streaming_response.remove(
models=["string"],
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncModel:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_add(self, async_client: AsyncHanzo) -> None:
model = await async_client.team.model.add(
models=["string"],
team_id="team_id",
)
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_raw_response_add(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.model.with_raw_response.add(
models=["string"],
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_streaming_response_add(self, async_client: AsyncHanzo) -> None:
async with async_client.team.model.with_streaming_response.add(
models=["string"],
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_remove(self, async_client: AsyncHanzo) -> None:
model = await async_client.team.model.remove(
models=["string"],
team_id="team_id",
)
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_raw_response_remove(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.model.with_raw_response.remove(
models=["string"],
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_streaming_response_remove(self, async_client: AsyncHanzo) -> None:
async with async_client.team.model.with_streaming_response.remove(
models=["string"],
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_active.py
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestActive:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_list_callbacks(self, client: Hanzo) -> None:
active = client.active.list_callbacks()
assert_matches_type(object, active, path=["response"])
@parametrize
def test_raw_response_list_callbacks(self, client: Hanzo) -> None:
response = client.active.with_raw_response.list_callbacks()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
active = response.parse()
assert_matches_type(object, active, path=["response"])
@parametrize
def test_streaming_response_list_callbacks(self, client: Hanzo) -> None:
with client.active.with_streaming_response.list_callbacks() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
active = response.parse()
assert_matches_type(object, active, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncActive:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_list_callbacks(self, async_client: AsyncHanzo) -> None:
active = await async_client.active.list_callbacks()
assert_matches_type(object, active, path=["response"])
@parametrize
async def test_raw_response_list_callbacks(self, async_client: AsyncHanzo) -> None:
response = await async_client.active.with_raw_response.list_callbacks()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
active = await response.parse()
assert_matches_type(object, active, path=["response"])
@parametrize
async def test_streaming_response_list_callbacks(self, async_client: AsyncHanzo) -> None:
async with async_client.active.with_streaming_response.list_callbacks() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
active = await response.parse()
assert_matches_type(object, active, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_add.py
-83
View File
@@ -1,83 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestAdd:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_add_allowed_ip(self, client: Hanzo) -> None:
add = client.add.add_allowed_ip(
ip="ip",
)
assert_matches_type(object, add, path=["response"])
@parametrize
def test_raw_response_add_allowed_ip(self, client: Hanzo) -> None:
response = client.add.with_raw_response.add_allowed_ip(
ip="ip",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
add = response.parse()
assert_matches_type(object, add, path=["response"])
@parametrize
def test_streaming_response_add_allowed_ip(self, client: Hanzo) -> None:
with client.add.with_streaming_response.add_allowed_ip(
ip="ip",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
add = response.parse()
assert_matches_type(object, add, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncAdd:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_add_allowed_ip(self, async_client: AsyncHanzo) -> None:
add = await async_client.add.add_allowed_ip(
ip="ip",
)
assert_matches_type(object, add, path=["response"])
@parametrize
async def test_raw_response_add_allowed_ip(self, async_client: AsyncHanzo) -> None:
response = await async_client.add.with_raw_response.add_allowed_ip(
ip="ip",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
add = await response.parse()
assert_matches_type(object, add, path=["response"])
@parametrize
async def test_streaming_response_add_allowed_ip(self, async_client: AsyncHanzo) -> None:
async with async_client.add.with_streaming_response.add_allowed_ip(
ip="ip",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
add = await response.parse()
assert_matches_type(object, add, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_anthropic.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestAnthropic:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
anthropic = client.anthropic.create(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.anthropic.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.anthropic.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.anthropic.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
anthropic = client.anthropic.retrieve(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.anthropic.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.anthropic.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.anthropic.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
anthropic = client.anthropic.update(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.anthropic.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.anthropic.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.anthropic.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
anthropic = client.anthropic.delete(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.anthropic.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.anthropic.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.anthropic.with_raw_response.delete(
"",
)
@parametrize
def test_method_modify(self, client: Hanzo) -> None:
anthropic = client.anthropic.modify(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_raw_response_modify(self, client: Hanzo) -> None:
response = client.anthropic.with_raw_response.modify(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
def test_streaming_response_modify(self, client: Hanzo) -> None:
with client.anthropic.with_streaming_response.modify(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_modify(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.anthropic.with_raw_response.modify(
"",
)
class TestAsyncAnthropic:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
anthropic = await async_client.anthropic.create(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.anthropic.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.anthropic.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.anthropic.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
anthropic = await async_client.anthropic.retrieve(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.anthropic.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.anthropic.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.anthropic.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
anthropic = await async_client.anthropic.update(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.anthropic.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.anthropic.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.anthropic.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
anthropic = await async_client.anthropic.delete(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.anthropic.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.anthropic.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.anthropic.with_raw_response.delete(
"",
)
@parametrize
async def test_method_modify(self, async_client: AsyncHanzo) -> None:
anthropic = await async_client.anthropic.modify(
"endpoint",
)
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_raw_response_modify(self, async_client: AsyncHanzo) -> None:
response = await async_client.anthropic.with_raw_response.modify(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
@parametrize
async def test_streaming_response_modify(self, async_client: AsyncHanzo) -> None:
async with async_client.anthropic.with_streaming_response.modify(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
anthropic = await response.parse()
assert_matches_type(object, anthropic, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_modify(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.anthropic.with_raw_response.modify(
"",
)
tests/api_resources/test_assemblyai.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestAssemblyai:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
assemblyai = client.assemblyai.create(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.assemblyai.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.assemblyai.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.assemblyai.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
assemblyai = client.assemblyai.retrieve(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.assemblyai.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.assemblyai.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.assemblyai.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
assemblyai = client.assemblyai.update(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.assemblyai.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.assemblyai.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.assemblyai.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
assemblyai = client.assemblyai.delete(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.assemblyai.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.assemblyai.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.assemblyai.with_raw_response.delete(
"",
)
@parametrize
def test_method_patch(self, client: Hanzo) -> None:
assemblyai = client.assemblyai.patch(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_raw_response_patch(self, client: Hanzo) -> None:
response = client.assemblyai.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
def test_streaming_response_patch(self, client: Hanzo) -> None:
with client.assemblyai.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_patch(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.assemblyai.with_raw_response.patch(
"",
)
class TestAsyncAssemblyai:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
assemblyai = await async_client.assemblyai.create(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.assemblyai.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.assemblyai.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.assemblyai.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
assemblyai = await async_client.assemblyai.retrieve(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.assemblyai.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.assemblyai.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.assemblyai.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
assemblyai = await async_client.assemblyai.update(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.assemblyai.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.assemblyai.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.assemblyai.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
assemblyai = await async_client.assemblyai.delete(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.assemblyai.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.assemblyai.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.assemblyai.with_raw_response.delete(
"",
)
@parametrize
async def test_method_patch(self, async_client: AsyncHanzo) -> None:
assemblyai = await async_client.assemblyai.patch(
"endpoint",
)
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
response = await async_client.assemblyai.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
@parametrize
async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
async with async_client.assemblyai.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assemblyai = await response.parse()
assert_matches_type(object, assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.assemblyai.with_raw_response.patch(
"",
)
tests/api_resources/test_assistants.py
-203
View File
@@ -1,203 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestAssistants:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
assistant = client.assistants.create()
assert_matches_type(object, assistant, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.assistants.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = response.parse()
assert_matches_type(object, assistant, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.assistants.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = response.parse()
assert_matches_type(object, assistant, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list(self, client: Hanzo) -> None:
assistant = client.assistants.list()
assert_matches_type(object, assistant, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.assistants.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = response.parse()
assert_matches_type(object, assistant, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.assistants.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = response.parse()
assert_matches_type(object, assistant, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
assistant = client.assistants.delete(
"assistant_id",
)
assert_matches_type(object, assistant, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.assistants.with_raw_response.delete(
"assistant_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = response.parse()
assert_matches_type(object, assistant, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.assistants.with_streaming_response.delete(
"assistant_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = response.parse()
assert_matches_type(object, assistant, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `assistant_id` but received ''",
):
client.assistants.with_raw_response.delete(
"",
)
class TestAsyncAssistants:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
assistant = await async_client.assistants.create()
assert_matches_type(object, assistant, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.assistants.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = await response.parse()
assert_matches_type(object, assistant, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.assistants.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = await response.parse()
assert_matches_type(object, assistant, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
assistant = await async_client.assistants.list()
assert_matches_type(object, assistant, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.assistants.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = await response.parse()
assert_matches_type(object, assistant, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.assistants.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = await response.parse()
assert_matches_type(object, assistant, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
assistant = await async_client.assistants.delete(
"assistant_id",
)
assert_matches_type(object, assistant, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.assistants.with_raw_response.delete(
"assistant_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = await response.parse()
assert_matches_type(object, assistant, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.assistants.with_streaming_response.delete(
"assistant_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
assistant = await response.parse()
assert_matches_type(object, assistant, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `assistant_id` but received ''",
):
await async_client.assistants.with_raw_response.delete(
"",
)
tests/api_resources/test_azure.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestAzure:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
azure = client.azure.create(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.azure.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.azure.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.azure.with_raw_response.create(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
azure = client.azure.update(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.azure.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.azure.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.azure.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
azure = client.azure.delete(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.azure.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.azure.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.azure.with_raw_response.delete(
"",
)
@parametrize
def test_method_call(self, client: Hanzo) -> None:
azure = client.azure.call(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_raw_response_call(self, client: Hanzo) -> None:
response = client.azure.with_raw_response.call(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_streaming_response_call(self, client: Hanzo) -> None:
with client.azure.with_streaming_response.call(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_call(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.azure.with_raw_response.call(
"",
)
@parametrize
def test_method_patch(self, client: Hanzo) -> None:
azure = client.azure.patch(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_raw_response_patch(self, client: Hanzo) -> None:
response = client.azure.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
def test_streaming_response_patch(self, client: Hanzo) -> None:
with client.azure.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_patch(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.azure.with_raw_response.patch(
"",
)
class TestAsyncAzure:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
azure = await async_client.azure.create(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.azure.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.azure.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.azure.with_raw_response.create(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
azure = await async_client.azure.update(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.azure.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.azure.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.azure.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
azure = await async_client.azure.delete(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.azure.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.azure.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.azure.with_raw_response.delete(
"",
)
@parametrize
async def test_method_call(self, async_client: AsyncHanzo) -> None:
azure = await async_client.azure.call(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_raw_response_call(self, async_client: AsyncHanzo) -> None:
response = await async_client.azure.with_raw_response.call(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_streaming_response_call(self, async_client: AsyncHanzo) -> None:
async with async_client.azure.with_streaming_response.call(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_call(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.azure.with_raw_response.call(
"",
)
@parametrize
async def test_method_patch(self, async_client: AsyncHanzo) -> None:
azure = await async_client.azure.patch(
"endpoint",
)
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
response = await async_client.azure.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
@parametrize
async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
async with async_client.azure.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
azure = await response.parse()
assert_matches_type(object, azure, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.azure.with_raw_response.patch(
"",
)
tests/api_resources/test_batches.py
-649
View File
@@ -1,649 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestBatches:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
batch = client.batches.create()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
batch = client.batches.create(
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.batches.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.batches.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
batch = client.batches.retrieve(
batch_id="batch_id",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_method_retrieve_with_all_params(self, client: Hanzo) -> None:
batch = client.batches.retrieve(
batch_id="batch_id",
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.batches.with_raw_response.retrieve(
batch_id="batch_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.batches.with_streaming_response.retrieve(
batch_id="batch_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `batch_id` but received ''",
):
client.batches.with_raw_response.retrieve(
batch_id="",
)
@parametrize
def test_method_list(self, client: Hanzo) -> None:
batch = client.batches.list()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
batch = client.batches.list(
after="after",
limit=0,
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.batches.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.batches.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_cancel_with_provider(self, client: Hanzo) -> None:
batch = client.batches.cancel_with_provider(
batch_id="batch_id",
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_raw_response_cancel_with_provider(self, client: Hanzo) -> None:
response = client.batches.with_raw_response.cancel_with_provider(
batch_id="batch_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_streaming_response_cancel_with_provider(self, client: Hanzo) -> None:
with client.batches.with_streaming_response.cancel_with_provider(
batch_id="batch_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_cancel_with_provider(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.batches.with_raw_response.cancel_with_provider(
batch_id="batch_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `batch_id` but received ''",
):
client.batches.with_raw_response.cancel_with_provider(
batch_id="",
provider="provider",
)
@parametrize
def test_method_create_with_provider(self, client: Hanzo) -> None:
batch = client.batches.create_with_provider(
"provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_raw_response_create_with_provider(self, client: Hanzo) -> None:
response = client.batches.with_raw_response.create_with_provider(
"provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_streaming_response_create_with_provider(self, client: Hanzo) -> None:
with client.batches.with_streaming_response.create_with_provider(
"provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create_with_provider(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.batches.with_raw_response.create_with_provider(
"",
)
@parametrize
def test_method_list_with_provider(self, client: Hanzo) -> None:
batch = client.batches.list_with_provider(
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_method_list_with_provider_with_all_params(self, client: Hanzo) -> None:
batch = client.batches.list_with_provider(
provider="provider",
after="after",
limit=0,
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_raw_response_list_with_provider(self, client: Hanzo) -> None:
response = client.batches.with_raw_response.list_with_provider(
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_streaming_response_list_with_provider(self, client: Hanzo) -> None:
with client.batches.with_streaming_response.list_with_provider(
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_list_with_provider(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.batches.with_raw_response.list_with_provider(
provider="",
)
@parametrize
def test_method_retrieve_with_provider(self, client: Hanzo) -> None:
batch = client.batches.retrieve_with_provider(
batch_id="batch_id",
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_raw_response_retrieve_with_provider(self, client: Hanzo) -> None:
response = client.batches.with_raw_response.retrieve_with_provider(
batch_id="batch_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
def test_streaming_response_retrieve_with_provider(self, client: Hanzo) -> None:
with client.batches.with_streaming_response.retrieve_with_provider(
batch_id="batch_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve_with_provider(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.batches.with_raw_response.retrieve_with_provider(
batch_id="batch_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `batch_id` but received ''",
):
client.batches.with_raw_response.retrieve_with_provider(
batch_id="",
provider="provider",
)
class TestAsyncBatches:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.create()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.create(
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.batches.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.batches.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.retrieve(
batch_id="batch_id",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_method_retrieve_with_all_params(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.retrieve(
batch_id="batch_id",
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.batches.with_raw_response.retrieve(
batch_id="batch_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.batches.with_streaming_response.retrieve(
batch_id="batch_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `batch_id` but received ''",
):
await async_client.batches.with_raw_response.retrieve(
batch_id="",
)
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.list()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.list(
after="after",
limit=0,
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.batches.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.batches.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_cancel_with_provider(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.cancel_with_provider(
batch_id="batch_id",
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_raw_response_cancel_with_provider(self, async_client: AsyncHanzo) -> None:
response = await async_client.batches.with_raw_response.cancel_with_provider(
batch_id="batch_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_streaming_response_cancel_with_provider(self, async_client: AsyncHanzo) -> None:
async with async_client.batches.with_streaming_response.cancel_with_provider(
batch_id="batch_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_cancel_with_provider(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.batches.with_raw_response.cancel_with_provider(
batch_id="batch_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `batch_id` but received ''",
):
await async_client.batches.with_raw_response.cancel_with_provider(
batch_id="",
provider="provider",
)
@parametrize
async def test_method_create_with_provider(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.create_with_provider(
"provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_raw_response_create_with_provider(self, async_client: AsyncHanzo) -> None:
response = await async_client.batches.with_raw_response.create_with_provider(
"provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_streaming_response_create_with_provider(self, async_client: AsyncHanzo) -> None:
async with async_client.batches.with_streaming_response.create_with_provider(
"provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create_with_provider(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.batches.with_raw_response.create_with_provider(
"",
)
@parametrize
async def test_method_list_with_provider(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.list_with_provider(
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_method_list_with_provider_with_all_params(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.list_with_provider(
provider="provider",
after="after",
limit=0,
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_raw_response_list_with_provider(self, async_client: AsyncHanzo) -> None:
response = await async_client.batches.with_raw_response.list_with_provider(
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_streaming_response_list_with_provider(self, async_client: AsyncHanzo) -> None:
async with async_client.batches.with_streaming_response.list_with_provider(
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_list_with_provider(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.batches.with_raw_response.list_with_provider(
provider="",
)
@parametrize
async def test_method_retrieve_with_provider(self, async_client: AsyncHanzo) -> None:
batch = await async_client.batches.retrieve_with_provider(
batch_id="batch_id",
provider="provider",
)
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_raw_response_retrieve_with_provider(self, async_client: AsyncHanzo) -> None:
response = await async_client.batches.with_raw_response.retrieve_with_provider(
batch_id="batch_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
@parametrize
async def test_streaming_response_retrieve_with_provider(self, async_client: AsyncHanzo) -> None:
async with async_client.batches.with_streaming_response.retrieve_with_provider(
batch_id="batch_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
batch = await response.parse()
assert_matches_type(object, batch, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve_with_provider(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.batches.with_raw_response.retrieve_with_provider(
batch_id="batch_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `batch_id` but received ''",
):
await async_client.batches.with_raw_response.retrieve_with_provider(
batch_id="",
provider="provider",
)
tests/api_resources/test_bedrock.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestBedrock:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
bedrock = client.bedrock.create(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.bedrock.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.bedrock.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.bedrock.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
bedrock = client.bedrock.retrieve(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.bedrock.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.bedrock.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.bedrock.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
bedrock = client.bedrock.update(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.bedrock.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.bedrock.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.bedrock.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
bedrock = client.bedrock.delete(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.bedrock.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.bedrock.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.bedrock.with_raw_response.delete(
"",
)
@parametrize
def test_method_patch(self, client: Hanzo) -> None:
bedrock = client.bedrock.patch(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_raw_response_patch(self, client: Hanzo) -> None:
response = client.bedrock.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
def test_streaming_response_patch(self, client: Hanzo) -> None:
with client.bedrock.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_patch(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.bedrock.with_raw_response.patch(
"",
)
class TestAsyncBedrock:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
bedrock = await async_client.bedrock.create(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.bedrock.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.bedrock.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.bedrock.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
bedrock = await async_client.bedrock.retrieve(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.bedrock.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.bedrock.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.bedrock.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
bedrock = await async_client.bedrock.update(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.bedrock.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.bedrock.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.bedrock.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
bedrock = await async_client.bedrock.delete(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.bedrock.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.bedrock.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.bedrock.with_raw_response.delete(
"",
)
@parametrize
async def test_method_patch(self, async_client: AsyncHanzo) -> None:
bedrock = await async_client.bedrock.patch(
"endpoint",
)
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
response = await async_client.bedrock.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
@parametrize
async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
async with async_client.bedrock.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
bedrock = await response.parse()
assert_matches_type(object, bedrock, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.bedrock.with_raw_response.patch(
"",
)
tests/api_resources/test_budget.py
-441
View File
@@ -1,441 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestBudget:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
budget = client.budget.create()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
budget = client.budget.create(
budget_duration="budget_duration",
budget_id="budget_id",
max_budget=0,
max_parallel_requests=0,
model_max_budget={
"foo": {
"budget_duration": "budget_duration",
"max_budget": 0,
"rpm_limit": 0,
"tpm_limit": 0,
}
},
rpm_limit=0,
soft_budget=0,
tpm_limit=0,
)
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.budget.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.budget.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_update(self, client: Hanzo) -> None:
budget = client.budget.update()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_method_update_with_all_params(self, client: Hanzo) -> None:
budget = client.budget.update(
budget_duration="budget_duration",
budget_id="budget_id",
max_budget=0,
max_parallel_requests=0,
model_max_budget={
"foo": {
"budget_duration": "budget_duration",
"max_budget": 0,
"rpm_limit": 0,
"tpm_limit": 0,
}
},
rpm_limit=0,
soft_budget=0,
tpm_limit=0,
)
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.budget.with_raw_response.update()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.budget.with_streaming_response.update() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list(self, client: Hanzo) -> None:
budget = client.budget.list()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.budget.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.budget.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
budget = client.budget.delete(
id="id",
)
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.budget.with_raw_response.delete(
id="id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.budget.with_streaming_response.delete(
id="id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_info(self, client: Hanzo) -> None:
budget = client.budget.info(
budgets=["string"],
)
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_raw_response_info(self, client: Hanzo) -> None:
response = client.budget.with_raw_response.info(
budgets=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_streaming_response_info(self, client: Hanzo) -> None:
with client.budget.with_streaming_response.info(
budgets=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_settings(self, client: Hanzo) -> None:
budget = client.budget.settings(
budget_id="budget_id",
)
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_raw_response_settings(self, client: Hanzo) -> None:
response = client.budget.with_raw_response.settings(
budget_id="budget_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
def test_streaming_response_settings(self, client: Hanzo) -> None:
with client.budget.with_streaming_response.settings(
budget_id="budget_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncBudget:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
budget = await async_client.budget.create()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
budget = await async_client.budget.create(
budget_duration="budget_duration",
budget_id="budget_id",
max_budget=0,
max_parallel_requests=0,
model_max_budget={
"foo": {
"budget_duration": "budget_duration",
"max_budget": 0,
"rpm_limit": 0,
"tpm_limit": 0,
}
},
rpm_limit=0,
soft_budget=0,
tpm_limit=0,
)
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.budget.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.budget.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
budget = await async_client.budget.update()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
budget = await async_client.budget.update(
budget_duration="budget_duration",
budget_id="budget_id",
max_budget=0,
max_parallel_requests=0,
model_max_budget={
"foo": {
"budget_duration": "budget_duration",
"max_budget": 0,
"rpm_limit": 0,
"tpm_limit": 0,
}
},
rpm_limit=0,
soft_budget=0,
tpm_limit=0,
)
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.budget.with_raw_response.update()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.budget.with_streaming_response.update() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
budget = await async_client.budget.list()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.budget.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.budget.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
budget = await async_client.budget.delete(
id="id",
)
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.budget.with_raw_response.delete(
id="id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.budget.with_streaming_response.delete(
id="id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_info(self, async_client: AsyncHanzo) -> None:
budget = await async_client.budget.info(
budgets=["string"],
)
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_raw_response_info(self, async_client: AsyncHanzo) -> None:
response = await async_client.budget.with_raw_response.info(
budgets=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_streaming_response_info(self, async_client: AsyncHanzo) -> None:
async with async_client.budget.with_streaming_response.info(
budgets=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_settings(self, async_client: AsyncHanzo) -> None:
budget = await async_client.budget.settings(
budget_id="budget_id",
)
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_raw_response_settings(self, async_client: AsyncHanzo) -> None:
response = await async_client.budget.with_raw_response.settings(
budget_id="budget_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
@parametrize
async def test_streaming_response_settings(self, async_client: AsyncHanzo) -> None:
async with async_client.budget.with_streaming_response.settings(
budget_id="budget_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
budget = await response.parse()
assert_matches_type(object, budget, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_cache.py
-172
View File
@@ -1,172 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import CachePingResponse
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCache:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
cache = client.cache.delete()
assert_matches_type(object, cache, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.cache.with_raw_response.delete()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = response.parse()
assert_matches_type(object, cache, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.cache.with_streaming_response.delete() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = response.parse()
assert_matches_type(object, cache, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_flush_all(self, client: Hanzo) -> None:
cache = client.cache.flush_all()
assert_matches_type(object, cache, path=["response"])
@parametrize
def test_raw_response_flush_all(self, client: Hanzo) -> None:
response = client.cache.with_raw_response.flush_all()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = response.parse()
assert_matches_type(object, cache, path=["response"])
@parametrize
def test_streaming_response_flush_all(self, client: Hanzo) -> None:
with client.cache.with_streaming_response.flush_all() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = response.parse()
assert_matches_type(object, cache, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_ping(self, client: Hanzo) -> None:
cache = client.cache.ping()
assert_matches_type(CachePingResponse, cache, path=["response"])
@parametrize
def test_raw_response_ping(self, client: Hanzo) -> None:
response = client.cache.with_raw_response.ping()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = response.parse()
assert_matches_type(CachePingResponse, cache, path=["response"])
@parametrize
def test_streaming_response_ping(self, client: Hanzo) -> None:
with client.cache.with_streaming_response.ping() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = response.parse()
assert_matches_type(CachePingResponse, cache, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncCache:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
cache = await async_client.cache.delete()
assert_matches_type(object, cache, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.cache.with_raw_response.delete()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = await response.parse()
assert_matches_type(object, cache, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.cache.with_streaming_response.delete() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = await response.parse()
assert_matches_type(object, cache, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_flush_all(self, async_client: AsyncHanzo) -> None:
cache = await async_client.cache.flush_all()
assert_matches_type(object, cache, path=["response"])
@parametrize
async def test_raw_response_flush_all(self, async_client: AsyncHanzo) -> None:
response = await async_client.cache.with_raw_response.flush_all()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = await response.parse()
assert_matches_type(object, cache, path=["response"])
@parametrize
async def test_streaming_response_flush_all(self, async_client: AsyncHanzo) -> None:
async with async_client.cache.with_streaming_response.flush_all() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = await response.parse()
assert_matches_type(object, cache, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_ping(self, async_client: AsyncHanzo) -> None:
cache = await async_client.cache.ping()
assert_matches_type(CachePingResponse, cache, path=["response"])
@parametrize
async def test_raw_response_ping(self, async_client: AsyncHanzo) -> None:
response = await async_client.cache.with_raw_response.ping()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = await response.parse()
assert_matches_type(CachePingResponse, cache, path=["response"])
@parametrize
async def test_streaming_response_ping(self, async_client: AsyncHanzo) -> None:
async with async_client.cache.with_streaming_response.ping() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cache = await response.parse()
assert_matches_type(CachePingResponse, cache, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_client.py
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestClient:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_get_home(self, client: Hanzo) -> None:
client_ = client.get_home()
assert_matches_type(object, client_, path=["response"])
@parametrize
def test_raw_response_get_home(self, client: Hanzo) -> None:
response = client.with_raw_response.get_home()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
client_ = response.parse()
assert_matches_type(object, client_, path=["response"])
@parametrize
def test_streaming_response_get_home(self, client: Hanzo) -> None:
with client.with_streaming_response.get_home() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
client_ = response.parse()
assert_matches_type(object, client_, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncClient:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_get_home(self, async_client: AsyncHanzo) -> None:
client = await async_client.get_home()
assert_matches_type(object, client, path=["response"])
@parametrize
async def test_raw_response_get_home(self, async_client: AsyncHanzo) -> None:
response = await async_client.with_raw_response.get_home()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
client = await response.parse()
assert_matches_type(object, client, path=["response"])
@parametrize
async def test_streaming_response_get_home(self, async_client: AsyncHanzo) -> None:
async with async_client.with_streaming_response.get_home() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
client = await response.parse()
assert_matches_type(object, client, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_cohere.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCohere:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
cohere = client.cohere.create(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.cohere.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.cohere.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.cohere.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
cohere = client.cohere.retrieve(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.cohere.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.cohere.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.cohere.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
cohere = client.cohere.update(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.cohere.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.cohere.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.cohere.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
cohere = client.cohere.delete(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.cohere.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.cohere.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.cohere.with_raw_response.delete(
"",
)
@parametrize
def test_method_modify(self, client: Hanzo) -> None:
cohere = client.cohere.modify(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_raw_response_modify(self, client: Hanzo) -> None:
response = client.cohere.with_raw_response.modify(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
def test_streaming_response_modify(self, client: Hanzo) -> None:
with client.cohere.with_streaming_response.modify(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_modify(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.cohere.with_raw_response.modify(
"",
)
class TestAsyncCohere:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
cohere = await async_client.cohere.create(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.cohere.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.cohere.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.cohere.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
cohere = await async_client.cohere.retrieve(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.cohere.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.cohere.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.cohere.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
cohere = await async_client.cohere.update(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.cohere.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.cohere.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.cohere.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
cohere = await async_client.cohere.delete(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.cohere.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.cohere.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.cohere.with_raw_response.delete(
"",
)
@parametrize
async def test_method_modify(self, async_client: AsyncHanzo) -> None:
cohere = await async_client.cohere.modify(
"endpoint",
)
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_raw_response_modify(self, async_client: AsyncHanzo) -> None:
response = await async_client.cohere.with_raw_response.modify(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
@parametrize
async def test_streaming_response_modify(self, async_client: AsyncHanzo) -> None:
async with async_client.cohere.with_streaming_response.modify(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
cohere = await response.parse()
assert_matches_type(object, cohere, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_modify(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.cohere.with_raw_response.modify(
"",
)
tests/api_resources/test_completions.py
-85
View File
@@ -1,85 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCompletions:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
completion = client.completions.create()
assert_matches_type(object, completion, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
completion = client.completions.create(
model="model",
)
assert_matches_type(object, completion, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.completions.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
completion = response.parse()
assert_matches_type(object, completion, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.completions.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
completion = response.parse()
assert_matches_type(object, completion, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncCompletions:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
completion = await async_client.completions.create()
assert_matches_type(object, completion, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
completion = await async_client.completions.create(
model="model",
)
assert_matches_type(object, completion, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.completions.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
completion = await response.parse()
assert_matches_type(object, completion, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.completions.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
completion = await response.parse()
assert_matches_type(object, completion, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_credentials.py
-241
View File
@@ -1,241 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCredentials:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
credential = client.credentials.create(
credential_info={},
credential_name="credential_name",
)
assert_matches_type(object, credential, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
credential = client.credentials.create(
credential_info={},
credential_name="credential_name",
credential_values={},
model_id="model_id",
)
assert_matches_type(object, credential, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.credentials.with_raw_response.create(
credential_info={},
credential_name="credential_name",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = response.parse()
assert_matches_type(object, credential, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.credentials.with_streaming_response.create(
credential_info={},
credential_name="credential_name",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = response.parse()
assert_matches_type(object, credential, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list(self, client: Hanzo) -> None:
credential = client.credentials.list()
assert_matches_type(object, credential, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.credentials.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = response.parse()
assert_matches_type(object, credential, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.credentials.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = response.parse()
assert_matches_type(object, credential, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
credential = client.credentials.delete(
"credential_name",
)
assert_matches_type(object, credential, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.credentials.with_raw_response.delete(
"credential_name",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = response.parse()
assert_matches_type(object, credential, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.credentials.with_streaming_response.delete(
"credential_name",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = response.parse()
assert_matches_type(object, credential, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `credential_name` but received ''",
):
client.credentials.with_raw_response.delete(
"",
)
class TestAsyncCredentials:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
credential = await async_client.credentials.create(
credential_info={},
credential_name="credential_name",
)
assert_matches_type(object, credential, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
credential = await async_client.credentials.create(
credential_info={},
credential_name="credential_name",
credential_values={},
model_id="model_id",
)
assert_matches_type(object, credential, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.credentials.with_raw_response.create(
credential_info={},
credential_name="credential_name",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = await response.parse()
assert_matches_type(object, credential, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.credentials.with_streaming_response.create(
credential_info={},
credential_name="credential_name",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = await response.parse()
assert_matches_type(object, credential, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
credential = await async_client.credentials.list()
assert_matches_type(object, credential, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.credentials.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = await response.parse()
assert_matches_type(object, credential, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.credentials.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = await response.parse()
assert_matches_type(object, credential, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
credential = await async_client.credentials.delete(
"credential_name",
)
assert_matches_type(object, credential, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.credentials.with_raw_response.delete(
"credential_name",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = await response.parse()
assert_matches_type(object, credential, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.credentials.with_streaming_response.delete(
"credential_name",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
credential = await response.parse()
assert_matches_type(object, credential, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `credential_name` but received ''",
):
await async_client.credentials.with_raw_response.delete(
"",
)
tests/api_resources/test_customer.py
-525
View File
@@ -1,525 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import (
HanzoEndUserTable,
CustomerListResponse,
)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestCustomer:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
customer = client.customer.create(
user_id="user_id",
)
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
customer = client.customer.create(
user_id="user_id",
alias="alias",
allowed_model_region="eu",
blocked=True,
budget_duration="budget_duration",
budget_id="budget_id",
default_model="default_model",
max_budget=0,
max_parallel_requests=0,
model_max_budget={
"foo": {
"budget_duration": "budget_duration",
"max_budget": 0,
"rpm_limit": 0,
"tpm_limit": 0,
}
},
rpm_limit=0,
soft_budget=0,
tpm_limit=0,
)
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.customer.with_raw_response.create(
user_id="user_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.customer.with_streaming_response.create(
user_id="user_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_update(self, client: Hanzo) -> None:
customer = client.customer.update(
user_id="user_id",
)
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_method_update_with_all_params(self, client: Hanzo) -> None:
customer = client.customer.update(
user_id="user_id",
alias="alias",
allowed_model_region="eu",
blocked=True,
budget_id="budget_id",
default_model="default_model",
max_budget=0,
)
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.customer.with_raw_response.update(
user_id="user_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.customer.with_streaming_response.update(
user_id="user_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list(self, client: Hanzo) -> None:
customer = client.customer.list()
assert_matches_type(CustomerListResponse, customer, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.customer.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(CustomerListResponse, customer, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.customer.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(CustomerListResponse, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
customer = client.customer.delete(
user_ids=["string"],
)
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.customer.with_raw_response.delete(
user_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.customer.with_streaming_response.delete(
user_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_block(self, client: Hanzo) -> None:
customer = client.customer.block(
user_ids=["string"],
)
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_raw_response_block(self, client: Hanzo) -> None:
response = client.customer.with_raw_response.block(
user_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_streaming_response_block(self, client: Hanzo) -> None:
with client.customer.with_streaming_response.block(
user_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_retrieve_info(self, client: Hanzo) -> None:
customer = client.customer.retrieve_info(
end_user_id="end_user_id",
)
assert_matches_type(HanzoEndUserTable, customer, path=["response"])
@parametrize
def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
response = client.customer.with_raw_response.retrieve_info(
end_user_id="end_user_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(HanzoEndUserTable, customer, path=["response"])
@parametrize
def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
with client.customer.with_streaming_response.retrieve_info(
end_user_id="end_user_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(HanzoEndUserTable, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_unblock(self, client: Hanzo) -> None:
customer = client.customer.unblock(
user_ids=["string"],
)
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_raw_response_unblock(self, client: Hanzo) -> None:
response = client.customer.with_raw_response.unblock(
user_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
def test_streaming_response_unblock(self, client: Hanzo) -> None:
with client.customer.with_streaming_response.unblock(
user_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncCustomer:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.create(
user_id="user_id",
)
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.create(
user_id="user_id",
alias="alias",
allowed_model_region="eu",
blocked=True,
budget_duration="budget_duration",
budget_id="budget_id",
default_model="default_model",
max_budget=0,
max_parallel_requests=0,
model_max_budget={
"foo": {
"budget_duration": "budget_duration",
"max_budget": 0,
"rpm_limit": 0,
"tpm_limit": 0,
}
},
rpm_limit=0,
soft_budget=0,
tpm_limit=0,
)
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.customer.with_raw_response.create(
user_id="user_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.customer.with_streaming_response.create(
user_id="user_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.update(
user_id="user_id",
)
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.update(
user_id="user_id",
alias="alias",
allowed_model_region="eu",
blocked=True,
budget_id="budget_id",
default_model="default_model",
max_budget=0,
)
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.customer.with_raw_response.update(
user_id="user_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.customer.with_streaming_response.update(
user_id="user_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.list()
assert_matches_type(CustomerListResponse, customer, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.customer.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(CustomerListResponse, customer, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.customer.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(CustomerListResponse, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.delete(
user_ids=["string"],
)
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.customer.with_raw_response.delete(
user_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.customer.with_streaming_response.delete(
user_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_block(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.block(
user_ids=["string"],
)
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_raw_response_block(self, async_client: AsyncHanzo) -> None:
response = await async_client.customer.with_raw_response.block(
user_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_streaming_response_block(self, async_client: AsyncHanzo) -> None:
async with async_client.customer.with_streaming_response.block(
user_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.retrieve_info(
end_user_id="end_user_id",
)
assert_matches_type(HanzoEndUserTable, customer, path=["response"])
@parametrize
async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
response = await async_client.customer.with_raw_response.retrieve_info(
end_user_id="end_user_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(HanzoEndUserTable, customer, path=["response"])
@parametrize
async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
async with async_client.customer.with_streaming_response.retrieve_info(
end_user_id="end_user_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(HanzoEndUserTable, customer, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_unblock(self, async_client: AsyncHanzo) -> None:
customer = await async_client.customer.unblock(
user_ids=["string"],
)
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_raw_response_unblock(self, async_client: AsyncHanzo) -> None:
response = await async_client.customer.with_raw_response.unblock(
user_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
@parametrize
async def test_streaming_response_unblock(self, async_client: AsyncHanzo) -> None:
async with async_client.customer.with_streaming_response.unblock(
user_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
customer = await response.parse()
assert_matches_type(object, customer, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_delete.py
-83
View File
@@ -1,83 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestDelete:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create_allowed_ip(self, client: Hanzo) -> None:
delete = client.delete.create_allowed_ip(
ip="ip",
)
assert_matches_type(object, delete, path=["response"])
@parametrize
def test_raw_response_create_allowed_ip(self, client: Hanzo) -> None:
response = client.delete.with_raw_response.create_allowed_ip(
ip="ip",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
delete = response.parse()
assert_matches_type(object, delete, path=["response"])
@parametrize
def test_streaming_response_create_allowed_ip(self, client: Hanzo) -> None:
with client.delete.with_streaming_response.create_allowed_ip(
ip="ip",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
delete = response.parse()
assert_matches_type(object, delete, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncDelete:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create_allowed_ip(self, async_client: AsyncHanzo) -> None:
delete = await async_client.delete.create_allowed_ip(
ip="ip",
)
assert_matches_type(object, delete, path=["response"])
@parametrize
async def test_raw_response_create_allowed_ip(self, async_client: AsyncHanzo) -> None:
response = await async_client.delete.with_raw_response.create_allowed_ip(
ip="ip",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
delete = await response.parse()
assert_matches_type(object, delete, path=["response"])
@parametrize
async def test_streaming_response_create_allowed_ip(self, async_client: AsyncHanzo) -> None:
async with async_client.delete.with_streaming_response.create_allowed_ip(
ip="ip",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
delete = await response.parse()
assert_matches_type(object, delete, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_embeddings.py
-85
View File
@@ -1,85 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestEmbeddings:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
embedding = client.embeddings.create()
assert_matches_type(object, embedding, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
embedding = client.embeddings.create(
model="model",
)
assert_matches_type(object, embedding, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.embeddings.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
embedding = response.parse()
assert_matches_type(object, embedding, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.embeddings.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
embedding = response.parse()
assert_matches_type(object, embedding, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncEmbeddings:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
embedding = await async_client.embeddings.create()
assert_matches_type(object, embedding, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
embedding = await async_client.embeddings.create(
model="model",
)
assert_matches_type(object, embedding, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.embeddings.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
embedding = await response.parse()
assert_matches_type(object, embedding, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.embeddings.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
embedding = await response.parse()
assert_matches_type(object, embedding, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_engines.py
-173
View File
@@ -1,173 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestEngines:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_complete(self, client: Hanzo) -> None:
engine = client.engines.complete(
"model",
)
assert_matches_type(object, engine, path=["response"])
@parametrize
def test_raw_response_complete(self, client: Hanzo) -> None:
response = client.engines.with_raw_response.complete(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
engine = response.parse()
assert_matches_type(object, engine, path=["response"])
@parametrize
def test_streaming_response_complete(self, client: Hanzo) -> None:
with client.engines.with_streaming_response.complete(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
engine = response.parse()
assert_matches_type(object, engine, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_complete(self, client: Hanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
client.engines.with_raw_response.complete(
"",
)
@parametrize
def test_method_embed(self, client: Hanzo) -> None:
engine = client.engines.embed(
"model",
)
assert_matches_type(object, engine, path=["response"])
@parametrize
def test_raw_response_embed(self, client: Hanzo) -> None:
response = client.engines.with_raw_response.embed(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
engine = response.parse()
assert_matches_type(object, engine, path=["response"])
@parametrize
def test_streaming_response_embed(self, client: Hanzo) -> None:
with client.engines.with_streaming_response.embed(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
engine = response.parse()
assert_matches_type(object, engine, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_embed(self, client: Hanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
client.engines.with_raw_response.embed(
"",
)
class TestAsyncEngines:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_complete(self, async_client: AsyncHanzo) -> None:
engine = await async_client.engines.complete(
"model",
)
assert_matches_type(object, engine, path=["response"])
@parametrize
async def test_raw_response_complete(self, async_client: AsyncHanzo) -> None:
response = await async_client.engines.with_raw_response.complete(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
engine = await response.parse()
assert_matches_type(object, engine, path=["response"])
@parametrize
async def test_streaming_response_complete(self, async_client: AsyncHanzo) -> None:
async with async_client.engines.with_streaming_response.complete(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
engine = await response.parse()
assert_matches_type(object, engine, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_complete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
await async_client.engines.with_raw_response.complete(
"",
)
@parametrize
async def test_method_embed(self, async_client: AsyncHanzo) -> None:
engine = await async_client.engines.embed(
"model",
)
assert_matches_type(object, engine, path=["response"])
@parametrize
async def test_raw_response_embed(self, async_client: AsyncHanzo) -> None:
response = await async_client.engines.with_raw_response.embed(
"model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
engine = await response.parse()
assert_matches_type(object, engine, path=["response"])
@parametrize
async def test_streaming_response_embed(self, async_client: AsyncHanzo) -> None:
async with async_client.engines.with_streaming_response.embed(
"model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
engine = await response.parse()
assert_matches_type(object, engine, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_embed(self, async_client: AsyncHanzo) -> None:
with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
await async_client.engines.with_raw_response.embed(
"",
)
tests/api_resources/test_eu_assemblyai.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestEuAssemblyai:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
eu_assemblyai = client.eu_assemblyai.create(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.eu_assemblyai.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.eu_assemblyai.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.eu_assemblyai.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
eu_assemblyai = client.eu_assemblyai.retrieve(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.eu_assemblyai.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.eu_assemblyai.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.eu_assemblyai.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
eu_assemblyai = client.eu_assemblyai.update(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.eu_assemblyai.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.eu_assemblyai.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.eu_assemblyai.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
eu_assemblyai = client.eu_assemblyai.delete(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.eu_assemblyai.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.eu_assemblyai.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.eu_assemblyai.with_raw_response.delete(
"",
)
@parametrize
def test_method_patch(self, client: Hanzo) -> None:
eu_assemblyai = client.eu_assemblyai.patch(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_raw_response_patch(self, client: Hanzo) -> None:
response = client.eu_assemblyai.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
def test_streaming_response_patch(self, client: Hanzo) -> None:
with client.eu_assemblyai.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_patch(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.eu_assemblyai.with_raw_response.patch(
"",
)
class TestAsyncEuAssemblyai:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
eu_assemblyai = await async_client.eu_assemblyai.create(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.eu_assemblyai.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.eu_assemblyai.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.eu_assemblyai.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
eu_assemblyai = await async_client.eu_assemblyai.retrieve(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.eu_assemblyai.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.eu_assemblyai.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.eu_assemblyai.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
eu_assemblyai = await async_client.eu_assemblyai.update(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.eu_assemblyai.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.eu_assemblyai.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.eu_assemblyai.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
eu_assemblyai = await async_client.eu_assemblyai.delete(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.eu_assemblyai.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.eu_assemblyai.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.eu_assemblyai.with_raw_response.delete(
"",
)
@parametrize
async def test_method_patch(self, async_client: AsyncHanzo) -> None:
eu_assemblyai = await async_client.eu_assemblyai.patch(
"endpoint",
)
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
response = await async_client.eu_assemblyai.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
@parametrize
async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
async with async_client.eu_assemblyai.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
eu_assemblyai = await response.parse()
assert_matches_type(object, eu_assemblyai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.eu_assemblyai.with_raw_response.patch(
"",
)
tests/api_resources/test_files.py
-453
View File
@@ -1,453 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestFiles:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
file = client.files.create(
provider="provider",
file=b"raw file contents",
purpose="purpose",
)
assert_matches_type(object, file, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
file = client.files.create(
provider="provider",
file=b"raw file contents",
purpose="purpose",
custom_llm_provider="custom_llm_provider",
)
assert_matches_type(object, file, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.files.with_raw_response.create(
provider="provider",
file=b"raw file contents",
purpose="purpose",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = response.parse()
assert_matches_type(object, file, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.files.with_streaming_response.create(
provider="provider",
file=b"raw file contents",
purpose="purpose",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = response.parse()
assert_matches_type(object, file, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.files.with_raw_response.create(
provider="",
file=b"raw file contents",
purpose="purpose",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
file = client.files.retrieve(
file_id="file_id",
provider="provider",
)
assert_matches_type(object, file, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.files.with_raw_response.retrieve(
file_id="file_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = response.parse()
assert_matches_type(object, file, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.files.with_streaming_response.retrieve(
file_id="file_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = response.parse()
assert_matches_type(object, file, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.files.with_raw_response.retrieve(
file_id="file_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `file_id` but received ''",
):
client.files.with_raw_response.retrieve(
file_id="",
provider="provider",
)
@parametrize
def test_method_list(self, client: Hanzo) -> None:
file = client.files.list(
provider="provider",
)
assert_matches_type(object, file, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
file = client.files.list(
provider="provider",
purpose="purpose",
)
assert_matches_type(object, file, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.files.with_raw_response.list(
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = response.parse()
assert_matches_type(object, file, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.files.with_streaming_response.list(
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = response.parse()
assert_matches_type(object, file, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_list(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.files.with_raw_response.list(
provider="",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
file = client.files.delete(
file_id="file_id",
provider="provider",
)
assert_matches_type(object, file, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.files.with_raw_response.delete(
file_id="file_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = response.parse()
assert_matches_type(object, file, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.files.with_streaming_response.delete(
file_id="file_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = response.parse()
assert_matches_type(object, file, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
client.files.with_raw_response.delete(
file_id="file_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `file_id` but received ''",
):
client.files.with_raw_response.delete(
file_id="",
provider="provider",
)
class TestAsyncFiles:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
file = await async_client.files.create(
provider="provider",
file=b"raw file contents",
purpose="purpose",
)
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
file = await async_client.files.create(
provider="provider",
file=b"raw file contents",
purpose="purpose",
custom_llm_provider="custom_llm_provider",
)
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.files.with_raw_response.create(
provider="provider",
file=b"raw file contents",
purpose="purpose",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = await response.parse()
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.files.with_streaming_response.create(
provider="provider",
file=b"raw file contents",
purpose="purpose",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = await response.parse()
assert_matches_type(object, file, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.files.with_raw_response.create(
provider="",
file=b"raw file contents",
purpose="purpose",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
file = await async_client.files.retrieve(
file_id="file_id",
provider="provider",
)
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.files.with_raw_response.retrieve(
file_id="file_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = await response.parse()
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.files.with_streaming_response.retrieve(
file_id="file_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = await response.parse()
assert_matches_type(object, file, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.files.with_raw_response.retrieve(
file_id="file_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `file_id` but received ''",
):
await async_client.files.with_raw_response.retrieve(
file_id="",
provider="provider",
)
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
file = await async_client.files.list(
provider="provider",
)
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
file = await async_client.files.list(
provider="provider",
purpose="purpose",
)
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.files.with_raw_response.list(
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = await response.parse()
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.files.with_streaming_response.list(
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = await response.parse()
assert_matches_type(object, file, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_list(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.files.with_raw_response.list(
provider="",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
file = await async_client.files.delete(
file_id="file_id",
provider="provider",
)
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.files.with_raw_response.delete(
file_id="file_id",
provider="provider",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = await response.parse()
assert_matches_type(object, file, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.files.with_streaming_response.delete(
file_id="file_id",
provider="provider",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
file = await response.parse()
assert_matches_type(object, file, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `provider` but received ''",
):
await async_client.files.with_raw_response.delete(
file_id="file_id",
provider="",
)
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `file_id` but received ''",
):
await async_client.files.with_raw_response.delete(
file_id="",
provider="provider",
)
tests/api_resources/test_gemini.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestGemini:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
gemini = client.gemini.create(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.gemini.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.gemini.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.gemini.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
gemini = client.gemini.retrieve(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.gemini.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.gemini.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.gemini.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
gemini = client.gemini.update(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.gemini.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.gemini.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.gemini.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
gemini = client.gemini.delete(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.gemini.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.gemini.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.gemini.with_raw_response.delete(
"",
)
@parametrize
def test_method_patch(self, client: Hanzo) -> None:
gemini = client.gemini.patch(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_raw_response_patch(self, client: Hanzo) -> None:
response = client.gemini.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
def test_streaming_response_patch(self, client: Hanzo) -> None:
with client.gemini.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_patch(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.gemini.with_raw_response.patch(
"",
)
class TestAsyncGemini:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
gemini = await async_client.gemini.create(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.gemini.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.gemini.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.gemini.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
gemini = await async_client.gemini.retrieve(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.gemini.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.gemini.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.gemini.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
gemini = await async_client.gemini.update(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.gemini.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.gemini.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.gemini.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
gemini = await async_client.gemini.delete(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.gemini.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.gemini.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.gemini.with_raw_response.delete(
"",
)
@parametrize
async def test_method_patch(self, async_client: AsyncHanzo) -> None:
gemini = await async_client.gemini.patch(
"endpoint",
)
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
response = await async_client.gemini.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
@parametrize
async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
async with async_client.gemini.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
gemini = await response.parse()
assert_matches_type(object, gemini, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.gemini.with_raw_response.patch(
"",
)
tests/api_resources/test_guardrails.py
-72
View File
@@ -1,72 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import GuardrailListResponse
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestGuardrails:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_list(self, client: Hanzo) -> None:
guardrail = client.guardrails.list()
assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.guardrails.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
guardrail = response.parse()
assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.guardrails.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
guardrail = response.parse()
assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncGuardrails:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
guardrail = await async_client.guardrails.list()
assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.guardrails.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
guardrail = await response.parse()
assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.guardrails.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
guardrail = await response.parse()
assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_health.py
-297
View File
@@ -1,297 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestHealth:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_check_all(self, client: Hanzo) -> None:
health = client.health.check_all()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_method_check_all_with_all_params(self, client: Hanzo) -> None:
health = client.health.check_all(
model="model",
)
assert_matches_type(object, health, path=["response"])
@parametrize
def test_raw_response_check_all(self, client: Hanzo) -> None:
response = client.health.with_raw_response.check_all()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_streaming_response_check_all(self, client: Hanzo) -> None:
with client.health.with_streaming_response.check_all() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_check_liveliness(self, client: Hanzo) -> None:
health = client.health.check_liveliness()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_raw_response_check_liveliness(self, client: Hanzo) -> None:
response = client.health.with_raw_response.check_liveliness()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_streaming_response_check_liveliness(self, client: Hanzo) -> None:
with client.health.with_streaming_response.check_liveliness() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_check_liveness(self, client: Hanzo) -> None:
health = client.health.check_liveness()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_raw_response_check_liveness(self, client: Hanzo) -> None:
response = client.health.with_raw_response.check_liveness()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_streaming_response_check_liveness(self, client: Hanzo) -> None:
with client.health.with_streaming_response.check_liveness() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_check_readiness(self, client: Hanzo) -> None:
health = client.health.check_readiness()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_raw_response_check_readiness(self, client: Hanzo) -> None:
response = client.health.with_raw_response.check_readiness()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_streaming_response_check_readiness(self, client: Hanzo) -> None:
with client.health.with_streaming_response.check_readiness() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_check_services(self, client: Hanzo) -> None:
health = client.health.check_services(
service="slack_budget_alerts",
)
assert_matches_type(object, health, path=["response"])
@parametrize
def test_raw_response_check_services(self, client: Hanzo) -> None:
response = client.health.with_raw_response.check_services(
service="slack_budget_alerts",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
def test_streaming_response_check_services(self, client: Hanzo) -> None:
with client.health.with_streaming_response.check_services(
service="slack_budget_alerts",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncHealth:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_check_all(self, async_client: AsyncHanzo) -> None:
health = await async_client.health.check_all()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_method_check_all_with_all_params(self, async_client: AsyncHanzo) -> None:
health = await async_client.health.check_all(
model="model",
)
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_raw_response_check_all(self, async_client: AsyncHanzo) -> None:
response = await async_client.health.with_raw_response.check_all()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_streaming_response_check_all(self, async_client: AsyncHanzo) -> None:
async with async_client.health.with_streaming_response.check_all() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_check_liveliness(self, async_client: AsyncHanzo) -> None:
health = await async_client.health.check_liveliness()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_raw_response_check_liveliness(self, async_client: AsyncHanzo) -> None:
response = await async_client.health.with_raw_response.check_liveliness()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_streaming_response_check_liveliness(self, async_client: AsyncHanzo) -> None:
async with async_client.health.with_streaming_response.check_liveliness() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_check_liveness(self, async_client: AsyncHanzo) -> None:
health = await async_client.health.check_liveness()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_raw_response_check_liveness(self, async_client: AsyncHanzo) -> None:
response = await async_client.health.with_raw_response.check_liveness()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_streaming_response_check_liveness(self, async_client: AsyncHanzo) -> None:
async with async_client.health.with_streaming_response.check_liveness() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_check_readiness(self, async_client: AsyncHanzo) -> None:
health = await async_client.health.check_readiness()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_raw_response_check_readiness(self, async_client: AsyncHanzo) -> None:
response = await async_client.health.with_raw_response.check_readiness()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_streaming_response_check_readiness(self, async_client: AsyncHanzo) -> None:
async with async_client.health.with_streaming_response.check_readiness() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_check_services(self, async_client: AsyncHanzo) -> None:
health = await async_client.health.check_services(
service="slack_budget_alerts",
)
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_raw_response_check_services(self, async_client: AsyncHanzo) -> None:
response = await async_client.health.with_raw_response.check_services(
service="slack_budget_alerts",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
@parametrize
async def test_streaming_response_check_services(self, async_client: AsyncHanzo) -> None:
async with async_client.health.with_streaming_response.check_services(
service="slack_budget_alerts",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
health = await response.parse()
assert_matches_type(object, health, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_key.py
-848
View File
@@ -1,848 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, Optional, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import (
KeyListResponse,
KeyBlockResponse,
GenerateKeyResponse,
KeyCheckHealthResponse,
)
from hanzoai._utils import parse_datetime
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestKey:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_update(self, client: Hanzo) -> None:
key = client.key.update(
key="key",
)
assert_matches_type(object, key, path=["response"])
@parametrize
def test_method_update_with_all_params(self, client: Hanzo) -> None:
key = client.key.update(
key="key",
aliases={},
allowed_cache_controls=[{}],
blocked=True,
budget_duration="budget_duration",
budget_id="budget_id",
config={},
duration="duration",
enforced_params=["string"],
guardrails=["string"],
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
permissions={},
rpm_limit=0,
spend=0,
tags=["string"],
team_id="team_id",
temp_budget_expiry=parse_datetime("2019-12-27T18:11:19.117Z"),
temp_budget_increase=0,
tpm_limit=0,
user_id="user_id",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, key, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.key.with_raw_response.update(
key="key",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(object, key, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.key.with_streaming_response.update(
key="key",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(object, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list(self, client: Hanzo) -> None:
key = client.key.list()
assert_matches_type(KeyListResponse, key, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
key = client.key.list(
include_team_keys=True,
key_alias="key_alias",
organization_id="organization_id",
page=1,
return_full_object=True,
size=1,
team_id="team_id",
user_id="user_id",
)
assert_matches_type(KeyListResponse, key, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.key.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(KeyListResponse, key, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.key.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(KeyListResponse, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
key = client.key.delete()
assert_matches_type(object, key, path=["response"])
@parametrize
def test_method_delete_with_all_params(self, client: Hanzo) -> None:
key = client.key.delete(
key_aliases=["string"],
keys=["string"],
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, key, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.key.with_raw_response.delete()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(object, key, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.key.with_streaming_response.delete() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(object, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_block(self, client: Hanzo) -> None:
key = client.key.block(
key="key",
)
assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
@parametrize
def test_method_block_with_all_params(self, client: Hanzo) -> None:
key = client.key.block(
key="key",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
@parametrize
def test_raw_response_block(self, client: Hanzo) -> None:
response = client.key.with_raw_response.block(
key="key",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
@parametrize
def test_streaming_response_block(self, client: Hanzo) -> None:
with client.key.with_streaming_response.block(
key="key",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_check_health(self, client: Hanzo) -> None:
key = client.key.check_health()
assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
@parametrize
def test_raw_response_check_health(self, client: Hanzo) -> None:
response = client.key.with_raw_response.check_health()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
@parametrize
def test_streaming_response_check_health(self, client: Hanzo) -> None:
with client.key.with_streaming_response.check_health() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_generate(self, client: Hanzo) -> None:
key = client.key.generate()
assert_matches_type(GenerateKeyResponse, key, path=["response"])
@parametrize
def test_method_generate_with_all_params(self, client: Hanzo) -> None:
key = client.key.generate(
aliases={},
allowed_cache_controls=[{}],
blocked=True,
budget_duration="budget_duration",
budget_id="budget_id",
config={},
duration="duration",
enforced_params=["string"],
guardrails=["string"],
key="key",
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
permissions={},
rpm_limit=0,
send_invite_email=True,
soft_budget=0,
spend=0,
tags=["string"],
team_id="team_id",
tpm_limit=0,
user_id="user_id",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(GenerateKeyResponse, key, path=["response"])
@parametrize
def test_raw_response_generate(self, client: Hanzo) -> None:
response = client.key.with_raw_response.generate()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(GenerateKeyResponse, key, path=["response"])
@parametrize
def test_streaming_response_generate(self, client: Hanzo) -> None:
with client.key.with_streaming_response.generate() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(GenerateKeyResponse, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_regenerate_by_key(self, client: Hanzo) -> None:
key = client.key.regenerate_by_key(
path_key="key",
)
assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
@parametrize
def test_method_regenerate_by_key_with_all_params(self, client: Hanzo) -> None:
key = client.key.regenerate_by_key(
path_key="key",
aliases={},
allowed_cache_controls=[{}],
blocked=True,
budget_duration="budget_duration",
budget_id="budget_id",
config={},
duration="duration",
enforced_params=["string"],
guardrails=["string"],
body_key="key",
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
new_master_key="new_master_key",
permissions={},
rpm_limit=0,
send_invite_email=True,
soft_budget=0,
spend=0,
tags=["string"],
team_id="team_id",
tpm_limit=0,
user_id="user_id",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
@parametrize
def test_raw_response_regenerate_by_key(self, client: Hanzo) -> None:
response = client.key.with_raw_response.regenerate_by_key(
path_key="key",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
@parametrize
def test_streaming_response_regenerate_by_key(self, client: Hanzo) -> None:
with client.key.with_streaming_response.regenerate_by_key(
path_key="key",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_regenerate_by_key(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `path_key` but received ''",
):
client.key.with_raw_response.regenerate_by_key(
path_key="",
body_key="",
)
@parametrize
def test_method_retrieve_info(self, client: Hanzo) -> None:
key = client.key.retrieve_info()
assert_matches_type(object, key, path=["response"])
@parametrize
def test_method_retrieve_info_with_all_params(self, client: Hanzo) -> None:
key = client.key.retrieve_info(
key="key",
)
assert_matches_type(object, key, path=["response"])
@parametrize
def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
response = client.key.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(object, key, path=["response"])
@parametrize
def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
with client.key.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(object, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_unblock(self, client: Hanzo) -> None:
key = client.key.unblock(
key="key",
)
assert_matches_type(object, key, path=["response"])
@parametrize
def test_method_unblock_with_all_params(self, client: Hanzo) -> None:
key = client.key.unblock(
key="key",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, key, path=["response"])
@parametrize
def test_raw_response_unblock(self, client: Hanzo) -> None:
response = client.key.with_raw_response.unblock(
key="key",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(object, key, path=["response"])
@parametrize
def test_streaming_response_unblock(self, client: Hanzo) -> None:
with client.key.with_streaming_response.unblock(
key="key",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = response.parse()
assert_matches_type(object, key, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncKey:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.update(
key="key",
)
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.update(
key="key",
aliases={},
allowed_cache_controls=[{}],
blocked=True,
budget_duration="budget_duration",
budget_id="budget_id",
config={},
duration="duration",
enforced_params=["string"],
guardrails=["string"],
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
permissions={},
rpm_limit=0,
spend=0,
tags=["string"],
team_id="team_id",
temp_budget_expiry=parse_datetime("2019-12-27T18:11:19.117Z"),
temp_budget_increase=0,
tpm_limit=0,
user_id="user_id",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.update(
key="key",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.update(
key="key",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(object, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.list()
assert_matches_type(KeyListResponse, key, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.list(
include_team_keys=True,
key_alias="key_alias",
organization_id="organization_id",
page=1,
return_full_object=True,
size=1,
team_id="team_id",
user_id="user_id",
)
assert_matches_type(KeyListResponse, key, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(KeyListResponse, key, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(KeyListResponse, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.delete()
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_method_delete_with_all_params(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.delete(
key_aliases=["string"],
keys=["string"],
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.delete()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.delete() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(object, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_block(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.block(
key="key",
)
assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
@parametrize
async def test_method_block_with_all_params(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.block(
key="key",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
@parametrize
async def test_raw_response_block(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.block(
key="key",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
@parametrize
async def test_streaming_response_block(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.block(
key="key",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_check_health(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.check_health()
assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
@parametrize
async def test_raw_response_check_health(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.check_health()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
@parametrize
async def test_streaming_response_check_health(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.check_health() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_generate(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.generate()
assert_matches_type(GenerateKeyResponse, key, path=["response"])
@parametrize
async def test_method_generate_with_all_params(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.generate(
aliases={},
allowed_cache_controls=[{}],
blocked=True,
budget_duration="budget_duration",
budget_id="budget_id",
config={},
duration="duration",
enforced_params=["string"],
guardrails=["string"],
key="key",
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
permissions={},
rpm_limit=0,
send_invite_email=True,
soft_budget=0,
spend=0,
tags=["string"],
team_id="team_id",
tpm_limit=0,
user_id="user_id",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(GenerateKeyResponse, key, path=["response"])
@parametrize
async def test_raw_response_generate(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.generate()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(GenerateKeyResponse, key, path=["response"])
@parametrize
async def test_streaming_response_generate(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.generate() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(GenerateKeyResponse, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_regenerate_by_key(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.regenerate_by_key(
path_key="key",
)
assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
@parametrize
async def test_method_regenerate_by_key_with_all_params(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.regenerate_by_key(
path_key="key",
aliases={},
allowed_cache_controls=[{}],
blocked=True,
budget_duration="budget_duration",
budget_id="budget_id",
config={},
duration="duration",
enforced_params=["string"],
guardrails=["string"],
body_key="key",
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
new_master_key="new_master_key",
permissions={},
rpm_limit=0,
send_invite_email=True,
soft_budget=0,
spend=0,
tags=["string"],
team_id="team_id",
tpm_limit=0,
user_id="user_id",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
@parametrize
async def test_raw_response_regenerate_by_key(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.regenerate_by_key(
path_key="key",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
@parametrize
async def test_streaming_response_regenerate_by_key(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.regenerate_by_key(
path_key="key",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_regenerate_by_key(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `path_key` but received ''",
):
await async_client.key.with_raw_response.regenerate_by_key(
path_key="",
body_key="",
)
@parametrize
async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.retrieve_info()
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_method_retrieve_info_with_all_params(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.retrieve_info(
key="key",
)
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(object, key, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_unblock(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.unblock(
key="key",
)
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_method_unblock_with_all_params(self, async_client: AsyncHanzo) -> None:
key = await async_client.key.unblock(
key="key",
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_raw_response_unblock(self, async_client: AsyncHanzo) -> None:
response = await async_client.key.with_raw_response.unblock(
key="key",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(object, key, path=["response"])
@parametrize
async def test_streaming_response_unblock(self, async_client: AsyncHanzo) -> None:
async with async_client.key.with_streaming_response.unblock(
key="key",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
key = await response.parse()
assert_matches_type(object, key, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_langfuse.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestLangfuse:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
langfuse = client.langfuse.create(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.langfuse.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.langfuse.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.langfuse.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
langfuse = client.langfuse.retrieve(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.langfuse.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.langfuse.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.langfuse.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
langfuse = client.langfuse.update(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.langfuse.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.langfuse.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.langfuse.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
langfuse = client.langfuse.delete(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.langfuse.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.langfuse.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.langfuse.with_raw_response.delete(
"",
)
@parametrize
def test_method_patch(self, client: Hanzo) -> None:
langfuse = client.langfuse.patch(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_raw_response_patch(self, client: Hanzo) -> None:
response = client.langfuse.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
def test_streaming_response_patch(self, client: Hanzo) -> None:
with client.langfuse.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_patch(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.langfuse.with_raw_response.patch(
"",
)
class TestAsyncLangfuse:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
langfuse = await async_client.langfuse.create(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.langfuse.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.langfuse.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.langfuse.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
langfuse = await async_client.langfuse.retrieve(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.langfuse.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.langfuse.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.langfuse.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
langfuse = await async_client.langfuse.update(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.langfuse.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.langfuse.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.langfuse.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
langfuse = await async_client.langfuse.delete(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.langfuse.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.langfuse.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.langfuse.with_raw_response.delete(
"",
)
@parametrize
async def test_method_patch(self, async_client: AsyncHanzo) -> None:
langfuse = await async_client.langfuse.patch(
"endpoint",
)
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
response = await async_client.langfuse.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
@parametrize
async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
async with async_client.langfuse.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
langfuse = await response.parse()
assert_matches_type(object, langfuse, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.langfuse.with_raw_response.patch(
"",
)
tests/api_resources/test_model.py
-262
View File
@@ -1,262 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai._utils import parse_datetime
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestModel:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
model = client.model.create(
hanzo_params={"model": "model"},
model_info={"id": "id"},
model_name="model_name",
)
assert_matches_type(object, model, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
model = client.model.create(
hanzo_params={
"model": "model",
"api_base": "api_base",
"api_key": "api_key",
"api_version": "api_version",
"aws_access_key_id": "aws_access_key_id",
"aws_region_name": "aws_region_name",
"aws_secret_access_key": "aws_secret_access_key",
"budget_duration": "budget_duration",
"configurable_clientside_auth_params": ["string"],
"custom_llm_provider": "custom_llm_provider",
"input_cost_per_second": 0,
"input_cost_per_token": 0,
"hanzo_trace_id": "hanzo_trace_id",
"max_budget": 0,
"max_file_size_mb": 0,
"max_retries": 0,
"merge_reasoning_content_in_choices": True,
"model_info": {},
"organization": "organization",
"output_cost_per_second": 0,
"output_cost_per_token": 0,
"region_name": "region_name",
"rpm": 0,
"stream_timeout": 0,
"timeout": 0,
"tpm": 0,
"use_in_pass_through": True,
"vertex_credentials": "string",
"vertex_location": "vertex_location",
"vertex_project": "vertex_project",
"watsonx_region_name": "watsonx_region_name",
},
model_info={
"id": "id",
"base_model": "base_model",
"created_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"created_by": "created_by",
"db_model": True,
"team_id": "team_id",
"team_public_model_name": "team_public_model_name",
"tier": "free",
"updated_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"updated_by": "updated_by",
},
model_name="model_name",
)
assert_matches_type(object, model, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.model.with_raw_response.create(
hanzo_params={"model": "model"},
model_info={"id": "id"},
model_name="model_name",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.model.with_streaming_response.create(
hanzo_params={"model": "model"},
model_info={"id": "id"},
model_name="model_name",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
model = client.model.delete(
id="id",
)
assert_matches_type(object, model, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.model.with_raw_response.delete(
id="id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.model.with_streaming_response.delete(
id="id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncModel:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
model = await async_client.model.create(
hanzo_params={"model": "model"},
model_info={"id": "id"},
model_name="model_name",
)
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
model = await async_client.model.create(
hanzo_params={
"model": "model",
"api_base": "api_base",
"api_key": "api_key",
"api_version": "api_version",
"aws_access_key_id": "aws_access_key_id",
"aws_region_name": "aws_region_name",
"aws_secret_access_key": "aws_secret_access_key",
"budget_duration": "budget_duration",
"configurable_clientside_auth_params": ["string"],
"custom_llm_provider": "custom_llm_provider",
"input_cost_per_second": 0,
"input_cost_per_token": 0,
"hanzo_trace_id": "hanzo_trace_id",
"max_budget": 0,
"max_file_size_mb": 0,
"max_retries": 0,
"merge_reasoning_content_in_choices": True,
"model_info": {},
"organization": "organization",
"output_cost_per_second": 0,
"output_cost_per_token": 0,
"region_name": "region_name",
"rpm": 0,
"stream_timeout": 0,
"timeout": 0,
"tpm": 0,
"use_in_pass_through": True,
"vertex_credentials": "string",
"vertex_location": "vertex_location",
"vertex_project": "vertex_project",
"watsonx_region_name": "watsonx_region_name",
},
model_info={
"id": "id",
"base_model": "base_model",
"created_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"created_by": "created_by",
"db_model": True,
"team_id": "team_id",
"team_public_model_name": "team_public_model_name",
"tier": "free",
"updated_at": parse_datetime("2019-12-27T18:11:19.117Z"),
"updated_by": "updated_by",
},
model_name="model_name",
)
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.model.with_raw_response.create(
hanzo_params={"model": "model"},
model_info={"id": "id"},
model_name="model_name",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.model.with_streaming_response.create(
hanzo_params={"model": "model"},
model_info={"id": "id"},
model_name="model_name",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
model = await async_client.model.delete(
id="id",
)
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.model.with_raw_response.delete(
id="id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.model.with_streaming_response.delete(
id="id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_model_group.py
-85
View File
@@ -1,85 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestModelGroup:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_retrieve_info(self, client: Hanzo) -> None:
model_group = client.model_group.retrieve_info()
assert_matches_type(object, model_group, path=["response"])
@parametrize
def test_method_retrieve_info_with_all_params(self, client: Hanzo) -> None:
model_group = client.model_group.retrieve_info(
model_group="model_group",
)
assert_matches_type(object, model_group, path=["response"])
@parametrize
def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
response = client.model_group.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model_group = response.parse()
assert_matches_type(object, model_group, path=["response"])
@parametrize
def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
with client.model_group.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model_group = response.parse()
assert_matches_type(object, model_group, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncModelGroup:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
model_group = await async_client.model_group.retrieve_info()
assert_matches_type(object, model_group, path=["response"])
@parametrize
async def test_method_retrieve_info_with_all_params(self, async_client: AsyncHanzo) -> None:
model_group = await async_client.model_group.retrieve_info(
model_group="model_group",
)
assert_matches_type(object, model_group, path=["response"])
@parametrize
async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
response = await async_client.model_group.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model_group = await response.parse()
assert_matches_type(object, model_group, path=["response"])
@parametrize
async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
async with async_client.model_group.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model_group = await response.parse()
assert_matches_type(object, model_group, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_models.py
-87
View File
@@ -1,87 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestModels:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_list(self, client: Hanzo) -> None:
model = client.models.list()
assert_matches_type(object, model, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
model = client.models.list(
return_wildcard_routes=True,
team_id="team_id",
)
assert_matches_type(object, model, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.models.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.models.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncModels:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
model = await async_client.models.list()
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
model = await async_client.models.list(
return_wildcard_routes=True,
team_id="team_id",
)
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.models.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.models.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
model = await response.parse()
assert_matches_type(object, model, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_moderations.py
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestModerations:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
moderation = client.moderations.create()
assert_matches_type(object, moderation, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.moderations.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
moderation = response.parse()
assert_matches_type(object, moderation, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.moderations.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
moderation = response.parse()
assert_matches_type(object, moderation, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncModerations:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
moderation = await async_client.moderations.create()
assert_matches_type(object, moderation, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.moderations.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
moderation = await response.parse()
assert_matches_type(object, moderation, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.moderations.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
moderation = await response.parse()
assert_matches_type(object, moderation, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_openai.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestOpenAI:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
openai = client.openai.create(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.openai.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.openai.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.openai.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
openai = client.openai.retrieve(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.openai.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.openai.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.openai.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
openai = client.openai.update(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.openai.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.openai.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.openai.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
openai = client.openai.delete(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.openai.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.openai.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.openai.with_raw_response.delete(
"",
)
@parametrize
def test_method_patch(self, client: Hanzo) -> None:
openai = client.openai.patch(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_raw_response_patch(self, client: Hanzo) -> None:
response = client.openai.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
def test_streaming_response_patch(self, client: Hanzo) -> None:
with client.openai.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_patch(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.openai.with_raw_response.patch(
"",
)
class TestAsyncOpenAI:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
openai = await async_client.openai.create(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.openai.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.openai.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.openai.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
openai = await async_client.openai.retrieve(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.openai.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.openai.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.openai.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
openai = await async_client.openai.update(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.openai.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.openai.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.openai.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
openai = await async_client.openai.delete(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.openai.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.openai.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.openai.with_raw_response.delete(
"",
)
@parametrize
async def test_method_patch(self, async_client: AsyncHanzo) -> None:
openai = await async_client.openai.patch(
"endpoint",
)
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
response = await async_client.openai.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
@parametrize
async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
async with async_client.openai.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
openai = await response.parse()
assert_matches_type(object, openai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.openai.with_raw_response.patch(
"",
)
tests/api_resources/test_organization.py
-577
View File
@@ -1,577 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import (
OrganizationListResponse,
OrganizationCreateResponse,
OrganizationDeleteResponse,
OrganizationUpdateResponse,
OrganizationAddMemberResponse,
OrganizationUpdateMemberResponse,
)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestOrganization:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
organization = client.organization.create(
organization_alias="organization_alias",
)
assert_matches_type(OrganizationCreateResponse, organization, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
organization = client.organization.create(
organization_alias="organization_alias",
budget_duration="budget_duration",
budget_id="budget_id",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
models=[{}],
organization_id="organization_id",
rpm_limit=0,
soft_budget=0,
tpm_limit=0,
)
assert_matches_type(OrganizationCreateResponse, organization, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.organization.with_raw_response.create(
organization_alias="organization_alias",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationCreateResponse, organization, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.organization.with_streaming_response.create(
organization_alias="organization_alias",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationCreateResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_update(self, client: Hanzo) -> None:
organization = client.organization.update()
assert_matches_type(OrganizationUpdateResponse, organization, path=["response"])
@parametrize
def test_method_update_with_all_params(self, client: Hanzo) -> None:
organization = client.organization.update(
budget_id="budget_id",
metadata={},
models=["string"],
organization_alias="organization_alias",
organization_id="organization_id",
spend=0,
updated_by="updated_by",
)
assert_matches_type(OrganizationUpdateResponse, organization, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.organization.with_raw_response.update()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationUpdateResponse, organization, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.organization.with_streaming_response.update() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationUpdateResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list(self, client: Hanzo) -> None:
organization = client.organization.list()
assert_matches_type(OrganizationListResponse, organization, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.organization.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationListResponse, organization, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.organization.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationListResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
organization = client.organization.delete(
organization_ids=["string"],
)
assert_matches_type(OrganizationDeleteResponse, organization, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.organization.with_raw_response.delete(
organization_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationDeleteResponse, organization, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.organization.with_streaming_response.delete(
organization_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationDeleteResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_add_member(self, client: Hanzo) -> None:
organization = client.organization.add_member(
member=[{"role": "org_admin"}],
organization_id="organization_id",
)
assert_matches_type(OrganizationAddMemberResponse, organization, path=["response"])
@parametrize
def test_method_add_member_with_all_params(self, client: Hanzo) -> None:
organization = client.organization.add_member(
member=[
{
"role": "org_admin",
"user_email": "user_email",
"user_id": "user_id",
}
],
organization_id="organization_id",
max_budget_in_organization=0,
)
assert_matches_type(OrganizationAddMemberResponse, organization, path=["response"])
@parametrize
def test_raw_response_add_member(self, client: Hanzo) -> None:
response = client.organization.with_raw_response.add_member(
member=[{"role": "org_admin"}],
organization_id="organization_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationAddMemberResponse, organization, path=["response"])
@parametrize
def test_streaming_response_add_member(self, client: Hanzo) -> None:
with client.organization.with_streaming_response.add_member(
member=[{"role": "org_admin"}],
organization_id="organization_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationAddMemberResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete_member(self, client: Hanzo) -> None:
organization = client.organization.delete_member(
organization_id="organization_id",
)
assert_matches_type(object, organization, path=["response"])
@parametrize
def test_method_delete_member_with_all_params(self, client: Hanzo) -> None:
organization = client.organization.delete_member(
organization_id="organization_id",
user_email="user_email",
user_id="user_id",
)
assert_matches_type(object, organization, path=["response"])
@parametrize
def test_raw_response_delete_member(self, client: Hanzo) -> None:
response = client.organization.with_raw_response.delete_member(
organization_id="organization_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(object, organization, path=["response"])
@parametrize
def test_streaming_response_delete_member(self, client: Hanzo) -> None:
with client.organization.with_streaming_response.delete_member(
organization_id="organization_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(object, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_update_member(self, client: Hanzo) -> None:
organization = client.organization.update_member(
organization_id="organization_id",
)
assert_matches_type(OrganizationUpdateMemberResponse, organization, path=["response"])
@parametrize
def test_method_update_member_with_all_params(self, client: Hanzo) -> None:
organization = client.organization.update_member(
organization_id="organization_id",
max_budget_in_organization=0,
role="proxy_admin",
user_email="user_email",
user_id="user_id",
)
assert_matches_type(OrganizationUpdateMemberResponse, organization, path=["response"])
@parametrize
def test_raw_response_update_member(self, client: Hanzo) -> None:
response = client.organization.with_raw_response.update_member(
organization_id="organization_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationUpdateMemberResponse, organization, path=["response"])
@parametrize
def test_streaming_response_update_member(self, client: Hanzo) -> None:
with client.organization.with_streaming_response.update_member(
organization_id="organization_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = response.parse()
assert_matches_type(OrganizationUpdateMemberResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncOrganization:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.create(
organization_alias="organization_alias",
)
assert_matches_type(OrganizationCreateResponse, organization, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.create(
organization_alias="organization_alias",
budget_duration="budget_duration",
budget_id="budget_id",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
models=[{}],
organization_id="organization_id",
rpm_limit=0,
soft_budget=0,
tpm_limit=0,
)
assert_matches_type(OrganizationCreateResponse, organization, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.with_raw_response.create(
organization_alias="organization_alias",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationCreateResponse, organization, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.with_streaming_response.create(
organization_alias="organization_alias",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationCreateResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.update()
assert_matches_type(OrganizationUpdateResponse, organization, path=["response"])
@parametrize
async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.update(
budget_id="budget_id",
metadata={},
models=["string"],
organization_alias="organization_alias",
organization_id="organization_id",
spend=0,
updated_by="updated_by",
)
assert_matches_type(OrganizationUpdateResponse, organization, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.with_raw_response.update()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationUpdateResponse, organization, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.with_streaming_response.update() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationUpdateResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.list()
assert_matches_type(OrganizationListResponse, organization, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationListResponse, organization, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationListResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.delete(
organization_ids=["string"],
)
assert_matches_type(OrganizationDeleteResponse, organization, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.with_raw_response.delete(
organization_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationDeleteResponse, organization, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.with_streaming_response.delete(
organization_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationDeleteResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_add_member(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.add_member(
member=[{"role": "org_admin"}],
organization_id="organization_id",
)
assert_matches_type(OrganizationAddMemberResponse, organization, path=["response"])
@parametrize
async def test_method_add_member_with_all_params(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.add_member(
member=[
{
"role": "org_admin",
"user_email": "user_email",
"user_id": "user_id",
}
],
organization_id="organization_id",
max_budget_in_organization=0,
)
assert_matches_type(OrganizationAddMemberResponse, organization, path=["response"])
@parametrize
async def test_raw_response_add_member(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.with_raw_response.add_member(
member=[{"role": "org_admin"}],
organization_id="organization_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationAddMemberResponse, organization, path=["response"])
@parametrize
async def test_streaming_response_add_member(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.with_streaming_response.add_member(
member=[{"role": "org_admin"}],
organization_id="organization_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationAddMemberResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete_member(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.delete_member(
organization_id="organization_id",
)
assert_matches_type(object, organization, path=["response"])
@parametrize
async def test_method_delete_member_with_all_params(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.delete_member(
organization_id="organization_id",
user_email="user_email",
user_id="user_id",
)
assert_matches_type(object, organization, path=["response"])
@parametrize
async def test_raw_response_delete_member(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.with_raw_response.delete_member(
organization_id="organization_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(object, organization, path=["response"])
@parametrize
async def test_streaming_response_delete_member(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.with_streaming_response.delete_member(
organization_id="organization_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(object, organization, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_update_member(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.update_member(
organization_id="organization_id",
)
assert_matches_type(OrganizationUpdateMemberResponse, organization, path=["response"])
@parametrize
async def test_method_update_member_with_all_params(self, async_client: AsyncHanzo) -> None:
organization = await async_client.organization.update_member(
organization_id="organization_id",
max_budget_in_organization=0,
role="proxy_admin",
user_email="user_email",
user_id="user_id",
)
assert_matches_type(OrganizationUpdateMemberResponse, organization, path=["response"])
@parametrize
async def test_raw_response_update_member(self, async_client: AsyncHanzo) -> None:
response = await async_client.organization.with_raw_response.update_member(
organization_id="organization_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationUpdateMemberResponse, organization, path=["response"])
@parametrize
async def test_streaming_response_update_member(self, async_client: AsyncHanzo) -> None:
async with async_client.organization.with_streaming_response.update_member(
organization_id="organization_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
organization = await response.parse()
assert_matches_type(OrganizationUpdateMemberResponse, organization, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_provider.py
-72
View File
@@ -1,72 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import ProviderListBudgetsResponse
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestProvider:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_list_budgets(self, client: Hanzo) -> None:
provider = client.provider.list_budgets()
assert_matches_type(ProviderListBudgetsResponse, provider, path=["response"])
@parametrize
def test_raw_response_list_budgets(self, client: Hanzo) -> None:
response = client.provider.with_raw_response.list_budgets()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
provider = response.parse()
assert_matches_type(ProviderListBudgetsResponse, provider, path=["response"])
@parametrize
def test_streaming_response_list_budgets(self, client: Hanzo) -> None:
with client.provider.with_streaming_response.list_budgets() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
provider = response.parse()
assert_matches_type(ProviderListBudgetsResponse, provider, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncProvider:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_list_budgets(self, async_client: AsyncHanzo) -> None:
provider = await async_client.provider.list_budgets()
assert_matches_type(ProviderListBudgetsResponse, provider, path=["response"])
@parametrize
async def test_raw_response_list_budgets(self, async_client: AsyncHanzo) -> None:
response = await async_client.provider.with_raw_response.list_budgets()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
provider = await response.parse()
assert_matches_type(ProviderListBudgetsResponse, provider, path=["response"])
@parametrize
async def test_streaming_response_list_budgets(self, async_client: AsyncHanzo) -> None:
async with async_client.provider.with_streaming_response.list_budgets() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
provider = await response.parse()
assert_matches_type(ProviderListBudgetsResponse, provider, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_rerank.py
-171
View File
@@ -1,171 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestRerank:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
rerank = client.rerank.create()
assert_matches_type(object, rerank, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.rerank.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = response.parse()
assert_matches_type(object, rerank, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.rerank.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = response.parse()
assert_matches_type(object, rerank, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_create_v1(self, client: Hanzo) -> None:
rerank = client.rerank.create_v1()
assert_matches_type(object, rerank, path=["response"])
@parametrize
def test_raw_response_create_v1(self, client: Hanzo) -> None:
response = client.rerank.with_raw_response.create_v1()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = response.parse()
assert_matches_type(object, rerank, path=["response"])
@parametrize
def test_streaming_response_create_v1(self, client: Hanzo) -> None:
with client.rerank.with_streaming_response.create_v1() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = response.parse()
assert_matches_type(object, rerank, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_create_v2(self, client: Hanzo) -> None:
rerank = client.rerank.create_v2()
assert_matches_type(object, rerank, path=["response"])
@parametrize
def test_raw_response_create_v2(self, client: Hanzo) -> None:
response = client.rerank.with_raw_response.create_v2()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = response.parse()
assert_matches_type(object, rerank, path=["response"])
@parametrize
def test_streaming_response_create_v2(self, client: Hanzo) -> None:
with client.rerank.with_streaming_response.create_v2() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = response.parse()
assert_matches_type(object, rerank, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncRerank:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
rerank = await async_client.rerank.create()
assert_matches_type(object, rerank, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.rerank.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = await response.parse()
assert_matches_type(object, rerank, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.rerank.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = await response.parse()
assert_matches_type(object, rerank, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_create_v1(self, async_client: AsyncHanzo) -> None:
rerank = await async_client.rerank.create_v1()
assert_matches_type(object, rerank, path=["response"])
@parametrize
async def test_raw_response_create_v1(self, async_client: AsyncHanzo) -> None:
response = await async_client.rerank.with_raw_response.create_v1()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = await response.parse()
assert_matches_type(object, rerank, path=["response"])
@parametrize
async def test_streaming_response_create_v1(self, async_client: AsyncHanzo) -> None:
async with async_client.rerank.with_streaming_response.create_v1() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = await response.parse()
assert_matches_type(object, rerank, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_create_v2(self, async_client: AsyncHanzo) -> None:
rerank = await async_client.rerank.create_v2()
assert_matches_type(object, rerank, path=["response"])
@parametrize
async def test_raw_response_create_v2(self, async_client: AsyncHanzo) -> None:
response = await async_client.rerank.with_raw_response.create_v2()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = await response.parse()
assert_matches_type(object, rerank, path=["response"])
@parametrize
async def test_streaming_response_create_v2(self, async_client: AsyncHanzo) -> None:
async with async_client.rerank.with_streaming_response.create_v2() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
rerank = await response.parse()
assert_matches_type(object, rerank, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_responses.py
-235
View File
@@ -1,235 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestResponses:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
response = client.responses.create()
assert_matches_type(object, response, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
http_response = client.responses.with_raw_response.create()
assert http_response.is_closed is True
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = http_response.parse()
assert_matches_type(object, response, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.responses.with_streaming_response.create() as http_response:
assert not http_response.is_closed
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = http_response.parse()
assert_matches_type(object, response, path=["response"])
assert cast(Any, http_response.is_closed) is True
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
response = client.responses.retrieve(
"response_id",
)
assert_matches_type(object, response, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
http_response = client.responses.with_raw_response.retrieve(
"response_id",
)
assert http_response.is_closed is True
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = http_response.parse()
assert_matches_type(object, response, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.responses.with_streaming_response.retrieve(
"response_id",
) as http_response:
assert not http_response.is_closed
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = http_response.parse()
assert_matches_type(object, response, path=["response"])
assert cast(Any, http_response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `response_id` but received ''",
):
client.responses.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
response = client.responses.delete(
"response_id",
)
assert_matches_type(object, response, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
http_response = client.responses.with_raw_response.delete(
"response_id",
)
assert http_response.is_closed is True
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = http_response.parse()
assert_matches_type(object, response, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.responses.with_streaming_response.delete(
"response_id",
) as http_response:
assert not http_response.is_closed
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = http_response.parse()
assert_matches_type(object, response, path=["response"])
assert cast(Any, http_response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `response_id` but received ''",
):
client.responses.with_raw_response.delete(
"",
)
class TestAsyncResponses:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.responses.create()
assert_matches_type(object, response, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
http_response = await async_client.responses.with_raw_response.create()
assert http_response.is_closed is True
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = await http_response.parse()
assert_matches_type(object, response, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.responses.with_streaming_response.create() as http_response:
assert not http_response.is_closed
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = await http_response.parse()
assert_matches_type(object, response, path=["response"])
assert cast(Any, http_response.is_closed) is True
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.responses.retrieve(
"response_id",
)
assert_matches_type(object, response, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
http_response = await async_client.responses.with_raw_response.retrieve(
"response_id",
)
assert http_response.is_closed is True
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = await http_response.parse()
assert_matches_type(object, response, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.responses.with_streaming_response.retrieve(
"response_id",
) as http_response:
assert not http_response.is_closed
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = await http_response.parse()
assert_matches_type(object, response, path=["response"])
assert cast(Any, http_response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `response_id` but received ''",
):
await async_client.responses.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.responses.delete(
"response_id",
)
assert_matches_type(object, response, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
http_response = await async_client.responses.with_raw_response.delete(
"response_id",
)
assert http_response.is_closed is True
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = await http_response.parse()
assert_matches_type(object, response, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.responses.with_streaming_response.delete(
"response_id",
) as http_response:
assert not http_response.is_closed
assert http_response.http_request.headers.get("X-SDK-Lang") == "python"
response = await http_response.parse()
assert_matches_type(object, response, path=["response"])
assert cast(Any, http_response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `response_id` but received ''",
):
await async_client.responses.with_raw_response.delete(
"",
)
tests/api_resources/test_routes.py
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestRoutes:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_list(self, client: Hanzo) -> None:
route = client.routes.list()
assert_matches_type(object, route, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.routes.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
route = response.parse()
assert_matches_type(object, route, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.routes.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
route = response.parse()
assert_matches_type(object, route, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncRoutes:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
route = await async_client.routes.list()
assert_matches_type(object, route, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.routes.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
route = await response.parse()
assert_matches_type(object, route, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.routes.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
route = await response.parse()
assert_matches_type(object, route, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_settings.py
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestSettings:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
setting = client.settings.retrieve()
assert_matches_type(object, setting, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.settings.with_raw_response.retrieve()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
setting = response.parse()
assert_matches_type(object, setting, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.settings.with_streaming_response.retrieve() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
setting = response.parse()
assert_matches_type(object, setting, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncSettings:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
setting = await async_client.settings.retrieve()
assert_matches_type(object, setting, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.settings.with_raw_response.retrieve()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
setting = await response.parse()
assert_matches_type(object, setting, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.settings.with_streaming_response.retrieve() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
setting = await response.parse()
assert_matches_type(object, setting, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_spend.py
-231
View File
@@ -1,231 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import (
SpendListLogsResponse,
SpendListTagsResponse,
)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestSpend:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_calculate_spend(self, client: Hanzo) -> None:
spend = client.spend.calculate_spend()
assert_matches_type(object, spend, path=["response"])
@parametrize
def test_method_calculate_spend_with_all_params(self, client: Hanzo) -> None:
spend = client.spend.calculate_spend(
completion_response={},
messages=[{}],
model="model",
)
assert_matches_type(object, spend, path=["response"])
@parametrize
def test_raw_response_calculate_spend(self, client: Hanzo) -> None:
response = client.spend.with_raw_response.calculate_spend()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(object, spend, path=["response"])
@parametrize
def test_streaming_response_calculate_spend(self, client: Hanzo) -> None:
with client.spend.with_streaming_response.calculate_spend() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(object, spend, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list_logs(self, client: Hanzo) -> None:
spend = client.spend.list_logs()
assert_matches_type(SpendListLogsResponse, spend, path=["response"])
@parametrize
def test_method_list_logs_with_all_params(self, client: Hanzo) -> None:
spend = client.spend.list_logs(
api_key="api_key",
end_date="end_date",
request_id="request_id",
start_date="start_date",
user_id="user_id",
)
assert_matches_type(SpendListLogsResponse, spend, path=["response"])
@parametrize
def test_raw_response_list_logs(self, client: Hanzo) -> None:
response = client.spend.with_raw_response.list_logs()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(SpendListLogsResponse, spend, path=["response"])
@parametrize
def test_streaming_response_list_logs(self, client: Hanzo) -> None:
with client.spend.with_streaming_response.list_logs() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(SpendListLogsResponse, spend, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list_tags(self, client: Hanzo) -> None:
spend = client.spend.list_tags()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
def test_method_list_tags_with_all_params(self, client: Hanzo) -> None:
spend = client.spend.list_tags(
end_date="end_date",
start_date="start_date",
)
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
def test_raw_response_list_tags(self, client: Hanzo) -> None:
response = client.spend.with_raw_response.list_tags()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
def test_streaming_response_list_tags(self, client: Hanzo) -> None:
with client.spend.with_streaming_response.list_tags() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = response.parse()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncSpend:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_calculate_spend(self, async_client: AsyncHanzo) -> None:
spend = await async_client.spend.calculate_spend()
assert_matches_type(object, spend, path=["response"])
@parametrize
async def test_method_calculate_spend_with_all_params(self, async_client: AsyncHanzo) -> None:
spend = await async_client.spend.calculate_spend(
completion_response={},
messages=[{}],
model="model",
)
assert_matches_type(object, spend, path=["response"])
@parametrize
async def test_raw_response_calculate_spend(self, async_client: AsyncHanzo) -> None:
response = await async_client.spend.with_raw_response.calculate_spend()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(object, spend, path=["response"])
@parametrize
async def test_streaming_response_calculate_spend(self, async_client: AsyncHanzo) -> None:
async with async_client.spend.with_streaming_response.calculate_spend() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(object, spend, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list_logs(self, async_client: AsyncHanzo) -> None:
spend = await async_client.spend.list_logs()
assert_matches_type(SpendListLogsResponse, spend, path=["response"])
@parametrize
async def test_method_list_logs_with_all_params(self, async_client: AsyncHanzo) -> None:
spend = await async_client.spend.list_logs(
api_key="api_key",
end_date="end_date",
request_id="request_id",
start_date="start_date",
user_id="user_id",
)
assert_matches_type(SpendListLogsResponse, spend, path=["response"])
@parametrize
async def test_raw_response_list_logs(self, async_client: AsyncHanzo) -> None:
response = await async_client.spend.with_raw_response.list_logs()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(SpendListLogsResponse, spend, path=["response"])
@parametrize
async def test_streaming_response_list_logs(self, async_client: AsyncHanzo) -> None:
async with async_client.spend.with_streaming_response.list_logs() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(SpendListLogsResponse, spend, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list_tags(self, async_client: AsyncHanzo) -> None:
spend = await async_client.spend.list_tags()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
async def test_method_list_tags_with_all_params(self, async_client: AsyncHanzo) -> None:
spend = await async_client.spend.list_tags(
end_date="end_date",
start_date="start_date",
)
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
async def test_raw_response_list_tags(self, async_client: AsyncHanzo) -> None:
response = await async_client.spend.with_raw_response.list_tags()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
@parametrize
async def test_streaming_response_list_tags(self, async_client: AsyncHanzo) -> None:
async with async_client.spend.with_streaming_response.list_tags() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
spend = await response.parse()
assert_matches_type(SpendListTagsResponse, spend, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_team.py
-976
View File
@@ -1,976 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import (
HanzoTeamTable,
TeamAddMemberResponse,
TeamUpdateMemberResponse,
)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestTeam:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
team = client.team.create()
assert_matches_type(HanzoTeamTable, team, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
team = client.team.create(
admins=[{}],
blocked=True,
budget_duration="budget_duration",
guardrails=["string"],
max_budget=0,
members=[{}],
members_with_roles=[
{
"role": "admin",
"user_email": "user_email",
"user_id": "user_id",
}
],
metadata={},
model_aliases={},
models=[{}],
organization_id="organization_id",
rpm_limit=0,
tags=[{}],
team_alias="team_alias",
team_id="team_id",
tpm_limit=0,
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(HanzoTeamTable, team, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.team.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(HanzoTeamTable, team, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.team.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(HanzoTeamTable, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_update(self, client: Hanzo) -> None:
team = client.team.update(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_method_update_with_all_params(self, client: Hanzo) -> None:
team = client.team.update(
team_id="team_id",
blocked=True,
budget_duration="budget_duration",
guardrails=["string"],
max_budget=0,
metadata={},
model_aliases={},
models=[{}],
organization_id="organization_id",
rpm_limit=0,
tags=[{}],
team_alias="team_alias",
tpm_limit=0,
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.team.with_raw_response.update(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.team.with_streaming_response.update(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list(self, client: Hanzo) -> None:
team = client.team.list()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
team = client.team.list(
organization_id="organization_id",
user_id="user_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.team.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.team.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
team = client.team.delete(
team_ids=["string"],
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_method_delete_with_all_params(self, client: Hanzo) -> None:
team = client.team.delete(
team_ids=["string"],
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.team.with_raw_response.delete(
team_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.team.with_streaming_response.delete(
team_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_add_member(self, client: Hanzo) -> None:
team = client.team.add_member(
member=[{"role": "admin"}],
team_id="team_id",
)
assert_matches_type(TeamAddMemberResponse, team, path=["response"])
@parametrize
def test_method_add_member_with_all_params(self, client: Hanzo) -> None:
team = client.team.add_member(
member=[
{
"role": "admin",
"user_email": "user_email",
"user_id": "user_id",
}
],
team_id="team_id",
max_budget_in_team=0,
)
assert_matches_type(TeamAddMemberResponse, team, path=["response"])
@parametrize
def test_raw_response_add_member(self, client: Hanzo) -> None:
response = client.team.with_raw_response.add_member(
member=[{"role": "admin"}],
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(TeamAddMemberResponse, team, path=["response"])
@parametrize
def test_streaming_response_add_member(self, client: Hanzo) -> None:
with client.team.with_streaming_response.add_member(
member=[{"role": "admin"}],
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(TeamAddMemberResponse, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_block(self, client: Hanzo) -> None:
team = client.team.block(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_block(self, client: Hanzo) -> None:
response = client.team.with_raw_response.block(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_block(self, client: Hanzo) -> None:
with client.team.with_streaming_response.block(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_disable_logging(self, client: Hanzo) -> None:
team = client.team.disable_logging(
"team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_disable_logging(self, client: Hanzo) -> None:
response = client.team.with_raw_response.disable_logging(
"team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_disable_logging(self, client: Hanzo) -> None:
with client.team.with_streaming_response.disable_logging(
"team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_disable_logging(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `team_id` but received ''",
):
client.team.with_raw_response.disable_logging(
"",
)
@parametrize
def test_method_list_available(self, client: Hanzo) -> None:
team = client.team.list_available()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_method_list_available_with_all_params(self, client: Hanzo) -> None:
team = client.team.list_available(
response_model={},
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_list_available(self, client: Hanzo) -> None:
response = client.team.with_raw_response.list_available()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_list_available(self, client: Hanzo) -> None:
with client.team.with_streaming_response.list_available() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_remove_member(self, client: Hanzo) -> None:
team = client.team.remove_member(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_method_remove_member_with_all_params(self, client: Hanzo) -> None:
team = client.team.remove_member(
team_id="team_id",
user_email="user_email",
user_id="user_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_remove_member(self, client: Hanzo) -> None:
response = client.team.with_raw_response.remove_member(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_remove_member(self, client: Hanzo) -> None:
with client.team.with_streaming_response.remove_member(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_retrieve_info(self, client: Hanzo) -> None:
team = client.team.retrieve_info()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_method_retrieve_info_with_all_params(self, client: Hanzo) -> None:
team = client.team.retrieve_info(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
response = client.team.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
with client.team.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_unblock(self, client: Hanzo) -> None:
team = client.team.unblock(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
def test_raw_response_unblock(self, client: Hanzo) -> None:
response = client.team.with_raw_response.unblock(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
def test_streaming_response_unblock(self, client: Hanzo) -> None:
with client.team.with_streaming_response.unblock(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_update_member(self, client: Hanzo) -> None:
team = client.team.update_member(
team_id="team_id",
)
assert_matches_type(TeamUpdateMemberResponse, team, path=["response"])
@parametrize
def test_method_update_member_with_all_params(self, client: Hanzo) -> None:
team = client.team.update_member(
team_id="team_id",
max_budget_in_team=0,
role="admin",
user_email="user_email",
user_id="user_id",
)
assert_matches_type(TeamUpdateMemberResponse, team, path=["response"])
@parametrize
def test_raw_response_update_member(self, client: Hanzo) -> None:
response = client.team.with_raw_response.update_member(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(TeamUpdateMemberResponse, team, path=["response"])
@parametrize
def test_streaming_response_update_member(self, client: Hanzo) -> None:
with client.team.with_streaming_response.update_member(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = response.parse()
assert_matches_type(TeamUpdateMemberResponse, team, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncTeam:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.create()
assert_matches_type(HanzoTeamTable, team, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.create(
admins=[{}],
blocked=True,
budget_duration="budget_duration",
guardrails=["string"],
max_budget=0,
members=[{}],
members_with_roles=[
{
"role": "admin",
"user_email": "user_email",
"user_id": "user_id",
}
],
metadata={},
model_aliases={},
models=[{}],
organization_id="organization_id",
rpm_limit=0,
tags=[{}],
team_alias="team_alias",
team_id="team_id",
tpm_limit=0,
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(HanzoTeamTable, team, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(HanzoTeamTable, team, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(HanzoTeamTable, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.update(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.update(
team_id="team_id",
blocked=True,
budget_duration="budget_duration",
guardrails=["string"],
max_budget=0,
metadata={},
model_aliases={},
models=[{}],
organization_id="organization_id",
rpm_limit=0,
tags=[{}],
team_alias="team_alias",
tpm_limit=0,
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.update(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.update(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.list()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.list(
organization_id="organization_id",
user_id="user_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.delete(
team_ids=["string"],
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_method_delete_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.delete(
team_ids=["string"],
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.delete(
team_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.delete(
team_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_add_member(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.add_member(
member=[{"role": "admin"}],
team_id="team_id",
)
assert_matches_type(TeamAddMemberResponse, team, path=["response"])
@parametrize
async def test_method_add_member_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.add_member(
member=[
{
"role": "admin",
"user_email": "user_email",
"user_id": "user_id",
}
],
team_id="team_id",
max_budget_in_team=0,
)
assert_matches_type(TeamAddMemberResponse, team, path=["response"])
@parametrize
async def test_raw_response_add_member(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.add_member(
member=[{"role": "admin"}],
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(TeamAddMemberResponse, team, path=["response"])
@parametrize
async def test_streaming_response_add_member(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.add_member(
member=[{"role": "admin"}],
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(TeamAddMemberResponse, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_block(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.block(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_block(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.block(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_block(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.block(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_disable_logging(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.disable_logging(
"team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_disable_logging(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.disable_logging(
"team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_disable_logging(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.disable_logging(
"team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_disable_logging(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `team_id` but received ''",
):
await async_client.team.with_raw_response.disable_logging(
"",
)
@parametrize
async def test_method_list_available(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.list_available()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_method_list_available_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.list_available(
response_model={},
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_list_available(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.list_available()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_list_available(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.list_available() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_remove_member(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.remove_member(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_method_remove_member_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.remove_member(
team_id="team_id",
user_email="user_email",
user_id="user_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_remove_member(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.remove_member(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_remove_member(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.remove_member(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.retrieve_info()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_method_retrieve_info_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.retrieve_info(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_unblock(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.unblock(
team_id="team_id",
)
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_raw_response_unblock(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.unblock(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
@parametrize
async def test_streaming_response_unblock(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.unblock(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(object, team, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_update_member(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.update_member(
team_id="team_id",
)
assert_matches_type(TeamUpdateMemberResponse, team, path=["response"])
@parametrize
async def test_method_update_member_with_all_params(self, async_client: AsyncHanzo) -> None:
team = await async_client.team.update_member(
team_id="team_id",
max_budget_in_team=0,
role="admin",
user_email="user_email",
user_id="user_id",
)
assert_matches_type(TeamUpdateMemberResponse, team, path=["response"])
@parametrize
async def test_raw_response_update_member(self, async_client: AsyncHanzo) -> None:
response = await async_client.team.with_raw_response.update_member(
team_id="team_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(TeamUpdateMemberResponse, team, path=["response"])
@parametrize
async def test_streaming_response_update_member(self, async_client: AsyncHanzo) -> None:
async with async_client.team.with_streaming_response.update_member(
team_id="team_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
team = await response.parse()
assert_matches_type(TeamUpdateMemberResponse, team, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_test.py
-71
View File
@@ -1,71 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestTest:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_ping(self, client: Hanzo) -> None:
test = client.test.ping()
assert_matches_type(object, test, path=["response"])
@parametrize
def test_raw_response_ping(self, client: Hanzo) -> None:
response = client.test.with_raw_response.ping()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
test = response.parse()
assert_matches_type(object, test, path=["response"])
@parametrize
def test_streaming_response_ping(self, client: Hanzo) -> None:
with client.test.with_streaming_response.ping() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
test = response.parse()
assert_matches_type(object, test, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncTest:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_ping(self, async_client: AsyncHanzo) -> None:
test = await async_client.test.ping()
assert_matches_type(object, test, path=["response"])
@parametrize
async def test_raw_response_ping(self, async_client: AsyncHanzo) -> None:
response = await async_client.test.with_raw_response.ping()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
test = await response.parse()
assert_matches_type(object, test, path=["response"])
@parametrize
async def test_streaming_response_ping(self, async_client: AsyncHanzo) -> None:
async with async_client.test.with_streaming_response.ping() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
test = await response.parse()
assert_matches_type(object, test, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_threads.py
-153
View File
@@ -1,153 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestThreads:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
thread = client.threads.create()
assert_matches_type(object, thread, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.threads.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
thread = response.parse()
assert_matches_type(object, thread, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.threads.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
thread = response.parse()
assert_matches_type(object, thread, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
thread = client.threads.retrieve(
"thread_id",
)
assert_matches_type(object, thread, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.threads.with_raw_response.retrieve(
"thread_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
thread = response.parse()
assert_matches_type(object, thread, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.threads.with_streaming_response.retrieve(
"thread_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
thread = response.parse()
assert_matches_type(object, thread, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `thread_id` but received ''",
):
client.threads.with_raw_response.retrieve(
"",
)
class TestAsyncThreads:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
thread = await async_client.threads.create()
assert_matches_type(object, thread, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.threads.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
thread = await response.parse()
assert_matches_type(object, thread, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.threads.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
thread = await response.parse()
assert_matches_type(object, thread, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
thread = await async_client.threads.retrieve(
"thread_id",
)
assert_matches_type(object, thread, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.threads.with_raw_response.retrieve(
"thread_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
thread = await response.parse()
assert_matches_type(object, thread, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.threads.with_streaming_response.retrieve(
"thread_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
thread = await response.parse()
assert_matches_type(object, thread, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `thread_id` but received ''",
):
await async_client.threads.with_raw_response.retrieve(
"",
)
tests/api_resources/test_user.py
-462
View File
@@ -1,462 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import (
UserCreateResponse,
)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestUser:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
user = client.user.create()
assert_matches_type(UserCreateResponse, user, path=["response"])
@parametrize
def test_method_create_with_all_params(self, client: Hanzo) -> None:
user = client.user.create(
aliases={},
allowed_cache_controls=[{}],
auto_create_key=True,
blocked=True,
budget_duration="budget_duration",
config={},
duration="duration",
guardrails=["string"],
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
permissions={},
rpm_limit=0,
send_invite_email=True,
spend=0,
team_id="team_id",
teams=[{}],
tpm_limit=0,
user_alias="user_alias",
user_email="user_email",
user_id="user_id",
user_role="proxy_admin",
)
assert_matches_type(UserCreateResponse, user, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.user.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(UserCreateResponse, user, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.user.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(UserCreateResponse, user, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_update(self, client: Hanzo) -> None:
user = client.user.update()
assert_matches_type(object, user, path=["response"])
@parametrize
def test_method_update_with_all_params(self, client: Hanzo) -> None:
user = client.user.update(
aliases={},
allowed_cache_controls=[{}],
blocked=True,
budget_duration="budget_duration",
config={},
duration="duration",
guardrails=["string"],
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
password="password",
permissions={},
rpm_limit=0,
spend=0,
team_id="team_id",
tpm_limit=0,
user_email="user_email",
user_id="user_id",
user_role="proxy_admin",
)
assert_matches_type(object, user, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.user.with_raw_response.update()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(object, user, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.user.with_streaming_response.update() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(object, user, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_list(self, client: Hanzo) -> None:
user = client.user.list()
assert_matches_type(object, user, path=["response"])
@parametrize
def test_method_list_with_all_params(self, client: Hanzo) -> None:
user = client.user.list(
page=1,
page_size=1,
role="role",
user_ids="user_ids",
)
assert_matches_type(object, user, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.user.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(object, user, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.user.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(object, user, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
user = client.user.delete(
user_ids=["string"],
)
assert_matches_type(object, user, path=["response"])
@parametrize
def test_method_delete_with_all_params(self, client: Hanzo) -> None:
user = client.user.delete(
user_ids=["string"],
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, user, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.user.with_raw_response.delete(
user_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(object, user, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.user.with_streaming_response.delete(
user_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(object, user, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_retrieve_info(self, client: Hanzo) -> None:
user = client.user.retrieve_info()
assert_matches_type(object, user, path=["response"])
@parametrize
def test_method_retrieve_info_with_all_params(self, client: Hanzo) -> None:
user = client.user.retrieve_info(
user_id="user_id",
)
assert_matches_type(object, user, path=["response"])
@parametrize
def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
response = client.user.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(object, user, path=["response"])
@parametrize
def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
with client.user.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = response.parse()
assert_matches_type(object, user, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncUser:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.create()
assert_matches_type(UserCreateResponse, user, path=["response"])
@parametrize
async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.create(
aliases={},
allowed_cache_controls=[{}],
auto_create_key=True,
blocked=True,
budget_duration="budget_duration",
config={},
duration="duration",
guardrails=["string"],
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
permissions={},
rpm_limit=0,
send_invite_email=True,
spend=0,
team_id="team_id",
teams=[{}],
tpm_limit=0,
user_alias="user_alias",
user_email="user_email",
user_id="user_id",
user_role="proxy_admin",
)
assert_matches_type(UserCreateResponse, user, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.user.with_raw_response.create()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(UserCreateResponse, user, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.user.with_streaming_response.create() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(UserCreateResponse, user, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.update()
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.update(
aliases={},
allowed_cache_controls=[{}],
blocked=True,
budget_duration="budget_duration",
config={},
duration="duration",
guardrails=["string"],
key_alias="key_alias",
max_budget=0,
max_parallel_requests=0,
metadata={},
model_max_budget={},
model_rpm_limit={},
model_tpm_limit={},
models=[{}],
password="password",
permissions={},
rpm_limit=0,
spend=0,
team_id="team_id",
tpm_limit=0,
user_email="user_email",
user_id="user_id",
user_role="proxy_admin",
)
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.user.with_raw_response.update()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.user.with_streaming_response.update() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(object, user, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.list()
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.list(
page=1,
page_size=1,
role="role",
user_ids="user_ids",
)
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.user.with_raw_response.list()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.user.with_streaming_response.list() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(object, user, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.delete(
user_ids=["string"],
)
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_method_delete_with_all_params(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.delete(
user_ids=["string"],
hanzo_changed_by="hanzo-changed-by",
)
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.user.with_raw_response.delete(
user_ids=["string"],
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.user.with_streaming_response.delete(
user_ids=["string"],
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(object, user, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.retrieve_info()
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_method_retrieve_info_with_all_params(self, async_client: AsyncHanzo) -> None:
user = await async_client.user.retrieve_info(
user_id="user_id",
)
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
response = await async_client.user.with_raw_response.retrieve_info()
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(object, user, path=["response"])
@parametrize
async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
async with async_client.user.with_streaming_response.retrieve_info() as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
user = await response.parse()
assert_matches_type(object, user, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_utils.py
-235
View File
@@ -1,235 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
from hanzoai.types import (
UtilTokenCounterResponse,
UtilTransformRequestResponse,
)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestUtils:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_get_supported_openai_params(self, client: Hanzo) -> None:
util = client.utils.get_supported_openai_params(
model="model",
)
assert_matches_type(object, util, path=["response"])
@parametrize
def test_raw_response_get_supported_openai_params(self, client: Hanzo) -> None:
response = client.utils.with_raw_response.get_supported_openai_params(
model="model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = response.parse()
assert_matches_type(object, util, path=["response"])
@parametrize
def test_streaming_response_get_supported_openai_params(self, client: Hanzo) -> None:
with client.utils.with_streaming_response.get_supported_openai_params(
model="model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = response.parse()
assert_matches_type(object, util, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_token_counter(self, client: Hanzo) -> None:
util = client.utils.token_counter(
model="model",
)
assert_matches_type(UtilTokenCounterResponse, util, path=["response"])
@parametrize
def test_method_token_counter_with_all_params(self, client: Hanzo) -> None:
util = client.utils.token_counter(
model="model",
messages=[{}],
prompt="prompt",
)
assert_matches_type(UtilTokenCounterResponse, util, path=["response"])
@parametrize
def test_raw_response_token_counter(self, client: Hanzo) -> None:
response = client.utils.with_raw_response.token_counter(
model="model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = response.parse()
assert_matches_type(UtilTokenCounterResponse, util, path=["response"])
@parametrize
def test_streaming_response_token_counter(self, client: Hanzo) -> None:
with client.utils.with_streaming_response.token_counter(
model="model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = response.parse()
assert_matches_type(UtilTokenCounterResponse, util, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_method_transform_request(self, client: Hanzo) -> None:
util = client.utils.transform_request(
call_type="embedding",
request_body={},
)
assert_matches_type(UtilTransformRequestResponse, util, path=["response"])
@parametrize
def test_raw_response_transform_request(self, client: Hanzo) -> None:
response = client.utils.with_raw_response.transform_request(
call_type="embedding",
request_body={},
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = response.parse()
assert_matches_type(UtilTransformRequestResponse, util, path=["response"])
@parametrize
def test_streaming_response_transform_request(self, client: Hanzo) -> None:
with client.utils.with_streaming_response.transform_request(
call_type="embedding",
request_body={},
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = response.parse()
assert_matches_type(UtilTransformRequestResponse, util, path=["response"])
assert cast(Any, response.is_closed) is True
class TestAsyncUtils:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_get_supported_openai_params(self, async_client: AsyncHanzo) -> None:
util = await async_client.utils.get_supported_openai_params(
model="model",
)
assert_matches_type(object, util, path=["response"])
@parametrize
async def test_raw_response_get_supported_openai_params(self, async_client: AsyncHanzo) -> None:
response = await async_client.utils.with_raw_response.get_supported_openai_params(
model="model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = await response.parse()
assert_matches_type(object, util, path=["response"])
@parametrize
async def test_streaming_response_get_supported_openai_params(self, async_client: AsyncHanzo) -> None:
async with async_client.utils.with_streaming_response.get_supported_openai_params(
model="model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = await response.parse()
assert_matches_type(object, util, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_token_counter(self, async_client: AsyncHanzo) -> None:
util = await async_client.utils.token_counter(
model="model",
)
assert_matches_type(UtilTokenCounterResponse, util, path=["response"])
@parametrize
async def test_method_token_counter_with_all_params(self, async_client: AsyncHanzo) -> None:
util = await async_client.utils.token_counter(
model="model",
messages=[{}],
prompt="prompt",
)
assert_matches_type(UtilTokenCounterResponse, util, path=["response"])
@parametrize
async def test_raw_response_token_counter(self, async_client: AsyncHanzo) -> None:
response = await async_client.utils.with_raw_response.token_counter(
model="model",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = await response.parse()
assert_matches_type(UtilTokenCounterResponse, util, path=["response"])
@parametrize
async def test_streaming_response_token_counter(self, async_client: AsyncHanzo) -> None:
async with async_client.utils.with_streaming_response.token_counter(
model="model",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = await response.parse()
assert_matches_type(UtilTokenCounterResponse, util, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_method_transform_request(self, async_client: AsyncHanzo) -> None:
util = await async_client.utils.transform_request(
call_type="embedding",
request_body={},
)
assert_matches_type(UtilTransformRequestResponse, util, path=["response"])
@parametrize
async def test_raw_response_transform_request(self, async_client: AsyncHanzo) -> None:
response = await async_client.utils.with_raw_response.transform_request(
call_type="embedding",
request_body={},
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = await response.parse()
assert_matches_type(UtilTransformRequestResponse, util, path=["response"])
@parametrize
async def test_streaming_response_transform_request(self, async_client: AsyncHanzo) -> None:
async with async_client.utils.with_streaming_response.transform_request(
call_type="embedding",
request_body={},
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
util = await response.parse()
assert_matches_type(UtilTransformRequestResponse, util, path=["response"])
assert cast(Any, response.is_closed) is True
tests/api_resources/test_vertex_ai.py
-431
View File
@@ -1,431 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestVertexAI:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
vertex_ai = client.vertex_ai.create(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.vertex_ai.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.vertex_ai.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.vertex_ai.with_raw_response.create(
"",
)
@parametrize
def test_method_retrieve(self, client: Hanzo) -> None:
vertex_ai = client.vertex_ai.retrieve(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_raw_response_retrieve(self, client: Hanzo) -> None:
response = client.vertex_ai.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_streaming_response_retrieve(self, client: Hanzo) -> None:
with client.vertex_ai.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_retrieve(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.vertex_ai.with_raw_response.retrieve(
"",
)
@parametrize
def test_method_update(self, client: Hanzo) -> None:
vertex_ai = client.vertex_ai.update(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_raw_response_update(self, client: Hanzo) -> None:
response = client.vertex_ai.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_streaming_response_update(self, client: Hanzo) -> None:
with client.vertex_ai.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_update(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.vertex_ai.with_raw_response.update(
"",
)
@parametrize
def test_method_delete(self, client: Hanzo) -> None:
vertex_ai = client.vertex_ai.delete(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_raw_response_delete(self, client: Hanzo) -> None:
response = client.vertex_ai.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_streaming_response_delete(self, client: Hanzo) -> None:
with client.vertex_ai.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_delete(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.vertex_ai.with_raw_response.delete(
"",
)
@parametrize
def test_method_patch(self, client: Hanzo) -> None:
vertex_ai = client.vertex_ai.patch(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_raw_response_patch(self, client: Hanzo) -> None:
response = client.vertex_ai.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
def test_streaming_response_patch(self, client: Hanzo) -> None:
with client.vertex_ai.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_patch(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
client.vertex_ai.with_raw_response.patch(
"",
)
class TestAsyncVertexAI:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
vertex_ai = await async_client.vertex_ai.create(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.vertex_ai.with_raw_response.create(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.vertex_ai.with_streaming_response.create(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.vertex_ai.with_raw_response.create(
"",
)
@parametrize
async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
vertex_ai = await async_client.vertex_ai.retrieve(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
response = await async_client.vertex_ai.with_raw_response.retrieve(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
async with async_client.vertex_ai.with_streaming_response.retrieve(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.vertex_ai.with_raw_response.retrieve(
"",
)
@parametrize
async def test_method_update(self, async_client: AsyncHanzo) -> None:
vertex_ai = await async_client.vertex_ai.update(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
response = await async_client.vertex_ai.with_raw_response.update(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
async with async_client.vertex_ai.with_streaming_response.update(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.vertex_ai.with_raw_response.update(
"",
)
@parametrize
async def test_method_delete(self, async_client: AsyncHanzo) -> None:
vertex_ai = await async_client.vertex_ai.delete(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
response = await async_client.vertex_ai.with_raw_response.delete(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
async with async_client.vertex_ai.with_streaming_response.delete(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.vertex_ai.with_raw_response.delete(
"",
)
@parametrize
async def test_method_patch(self, async_client: AsyncHanzo) -> None:
vertex_ai = await async_client.vertex_ai.patch(
"endpoint",
)
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
response = await async_client.vertex_ai.with_raw_response.patch(
"endpoint",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
@parametrize
async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
async with async_client.vertex_ai.with_streaming_response.patch(
"endpoint",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
vertex_ai = await response.parse()
assert_matches_type(object, vertex_ai, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `endpoint` but received ''",
):
await async_client.vertex_ai.with_raw_response.patch(
"",
)
tests/api_resources/threads/__init__.py
-1
View File
@@ -1 +0,0 @@
# # Hanzo AI SDK Tests
tests/api_resources/threads/test_messages.py
-185
View File
@@ -1,185 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestMessages:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
message = client.threads.messages.create(
"thread_id",
)
assert_matches_type(object, message, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.threads.messages.with_raw_response.create(
"thread_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
message = response.parse()
assert_matches_type(object, message, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.threads.messages.with_streaming_response.create(
"thread_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
message = response.parse()
assert_matches_type(object, message, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `thread_id` but received ''",
):
client.threads.messages.with_raw_response.create(
"",
)
@parametrize
def test_method_list(self, client: Hanzo) -> None:
message = client.threads.messages.list(
"thread_id",
)
assert_matches_type(object, message, path=["response"])
@parametrize
def test_raw_response_list(self, client: Hanzo) -> None:
response = client.threads.messages.with_raw_response.list(
"thread_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
message = response.parse()
assert_matches_type(object, message, path=["response"])
@parametrize
def test_streaming_response_list(self, client: Hanzo) -> None:
with client.threads.messages.with_streaming_response.list(
"thread_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
message = response.parse()
assert_matches_type(object, message, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_list(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `thread_id` but received ''",
):
client.threads.messages.with_raw_response.list(
"",
)
class TestAsyncMessages:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
message = await async_client.threads.messages.create(
"thread_id",
)
assert_matches_type(object, message, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.threads.messages.with_raw_response.create(
"thread_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
message = await response.parse()
assert_matches_type(object, message, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.threads.messages.with_streaming_response.create(
"thread_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
message = await response.parse()
assert_matches_type(object, message, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `thread_id` but received ''",
):
await async_client.threads.messages.with_raw_response.create(
"",
)
@parametrize
async def test_method_list(self, async_client: AsyncHanzo) -> None:
message = await async_client.threads.messages.list(
"thread_id",
)
assert_matches_type(object, message, path=["response"])
@parametrize
async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
response = await async_client.threads.messages.with_raw_response.list(
"thread_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
message = await response.parse()
assert_matches_type(object, message, path=["response"])
@parametrize
async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
async with async_client.threads.messages.with_streaming_response.list(
"thread_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
message = await response.parse()
assert_matches_type(object, message, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_list(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `thread_id` but received ''",
):
await async_client.threads.messages.with_raw_response.list(
"",
)
tests/api_resources/threads/test_runs.py
-103
View File
@@ -1,103 +0,0 @@
# # Hanzo AI SDK Tests
from __future__ import annotations
import os
from typing import Any, cast
import pytest
from hanzoai import Hanzo, AsyncHanzo
from tests.utils import assert_matches_type
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
class TestRuns:
parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
def test_method_create(self, client: Hanzo) -> None:
run = client.threads.runs.create(
"thread_id",
)
assert_matches_type(object, run, path=["response"])
@parametrize
def test_raw_response_create(self, client: Hanzo) -> None:
response = client.threads.runs.with_raw_response.create(
"thread_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
run = response.parse()
assert_matches_type(object, run, path=["response"])
@parametrize
def test_streaming_response_create(self, client: Hanzo) -> None:
with client.threads.runs.with_streaming_response.create(
"thread_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
run = response.parse()
assert_matches_type(object, run, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
def test_path_params_create(self, client: Hanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `thread_id` but received ''",
):
client.threads.runs.with_raw_response.create(
"",
)
class TestAsyncRuns:
parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@parametrize
async def test_method_create(self, async_client: AsyncHanzo) -> None:
run = await async_client.threads.runs.create(
"thread_id",
)
assert_matches_type(object, run, path=["response"])
@parametrize
async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
response = await async_client.threads.runs.with_raw_response.create(
"thread_id",
)
assert response.is_closed is True
assert response.http_request.headers.get("X-SDK-Lang") == "python"
run = await response.parse()
assert_matches_type(object, run, path=["response"])
@parametrize
async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
async with async_client.threads.runs.with_streaming_response.create(
"thread_id",
) as response:
assert not response.is_closed
assert response.http_request.headers.get("X-SDK-Lang") == "python"
run = await response.parse()
assert_matches_type(object, run, path=["response"])
assert cast(Any, response.is_closed) is True
@parametrize
async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
with pytest.raises(
ValueError,
match=r"Expected a non-empty value for `thread_id` but received ''",
):
await async_client.threads.runs.with_raw_response.create(
"",
)
tests/conformance/benchmark_parallel.py
-283
View File
@@ -1,283 +0,0 @@
#!/usr/bin/env python3
"""
HIP-0300 Parallel Performance Benchmark
Tests that all MCP tools work correctly when invoked concurrently.
Measures throughput and latency under parallel load.
Usage:
uv run python tests/conformance/benchmark_parallel.py
uv run python tests/conformance/benchmark_parallel.py --concurrency 20
"""
from __future__ import annotations
import os
import sys
import json
import time
import asyncio
import tempfile
import statistics
from typing import Any
from pathlib import Path
from dataclasses import field, dataclass
HANZO_ROOT = Path(os.environ.get("HANZO_ROOT", Path.home() / "work" / "hanzo"))
TIMEOUT = 30
STARTUP_TIMEOUT = 20
class MCPClient:
"""JSON-RPC 2.0 over stdio client."""
def __init__(self, command: list[str], cwd: Path, env: dict[str, str]):
self.command = command
self.cwd = cwd
self.env = env
self.proc: asyncio.subprocess.Process | None = None
self._id = 0
self._lock = asyncio.Lock()
async def start(self) -> None:
full_env = {**os.environ, **self.env}
self.proc = await asyncio.create_subprocess_exec(
*self.command,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
cwd=str(self.cwd),
env=full_env,
)
resp = await self._request("initialize", {
"protocolVersion": "2024-11-05",
"capabilities": {"tools": {}},
"clientInfo": {"name": "benchmark", "version": "1.0.0"},
})
if "error" in resp:
raise RuntimeError(f"Initialize failed: {resp['error']}")
await self._notify("notifications/initialized")
async def stop(self) -> None:
if self.proc and self.proc.returncode is None:
self.proc.terminate()
try:
await asyncio.wait_for(self.proc.wait(), timeout=5)
except asyncio.TimeoutError:
self.proc.kill()
async def call_tool(self, name: str, arguments: dict[str, Any]) -> dict:
return await self._request("tools/call", {"name": name, "arguments": arguments})
async def list_tools(self) -> list[dict]:
resp = await self._request("tools/list", {})
return resp.get("result", {}).get("tools", [])
async def _request(self, method: str, params: dict) -> dict:
async with self._lock:
self._id += 1
msg = {"jsonrpc": "2.0", "id": self._id, "method": method, "params": params}
return await self._send_and_recv(msg)
async def _notify(self, method: str, params: dict | None = None) -> None:
msg: dict[str, Any] = {"jsonrpc": "2.0", "method": method}
if params:
msg["params"] = params
assert self.proc and self.proc.stdin
self.proc.stdin.write(json.dumps(msg).encode() + b"\n")
await self.proc.stdin.drain()
async def _send_and_recv(self, msg: dict) -> dict:
assert self.proc and self.proc.stdin and self.proc.stdout
data = json.dumps(msg).encode() + b"\n"
self.proc.stdin.write(data)
await self.proc.stdin.drain()
deadline = time.monotonic() + TIMEOUT
while time.monotonic() < deadline:
try:
line = await asyncio.wait_for(
self.proc.stdout.readline(),
timeout=max(0.1, deadline - time.monotonic()),
)
except asyncio.TimeoutError:
break
if not line:
break
line = line.strip()
if not line:
continue
try:
resp = json.loads(line)
except json.JSONDecodeError:
continue
if resp.get("id") == msg["id"]:
return resp
return {"error": {"code": -1, "message": "Timeout"}}
@dataclass
class BenchResult:
tool: str
action: str
concurrency: int
total_calls: int
passed: int
failed: int
latencies_ms: list[float] = field(default_factory=list)
@property
def p50(self) -> float:
return statistics.median(self.latencies_ms) if self.latencies_ms else 0
@property
def p95(self) -> float:
if not self.latencies_ms:
return 0
sorted_l = sorted(self.latencies_ms)
idx = int(len(sorted_l) * 0.95)
return sorted_l[min(idx, len(sorted_l) - 1)]
@property
def throughput(self) -> float:
total_s = sum(self.latencies_ms) / 1000 if self.latencies_ms else 1
return self.total_calls / (total_s / self.concurrency) if total_s > 0 else 0
async def bench_tool(
client: MCPClient,
tool: str,
action: str,
params: dict[str, Any],
concurrency: int = 10,
iterations: int = 50,
) -> BenchResult:
"""Benchmark a tool with parallel invocations."""
result = BenchResult(
tool=tool, action=action, concurrency=concurrency,
total_calls=iterations, passed=0, failed=0,
)
sem = asyncio.Semaphore(concurrency)
async def single_call():
async with sem:
t0 = time.monotonic()
try:
resp = await asyncio.wait_for(
client.call_tool(tool, {"action": action, **params}),
timeout=TIMEOUT,
)
duration = (time.monotonic() - t0) * 1000
result.latencies_ms.append(duration)
if "error" in resp:
result.failed += 1
else:
result.passed += 1
except Exception:
result.failed += 1
result.latencies_ms.append((time.monotonic() - t0) * 1000)
# Run all calls concurrently
await asyncio.gather(*[single_call() for _ in range(iterations)])
return result
async def main():
import argparse
parser = argparse.ArgumentParser(description="HIP-0300 Parallel Benchmark")
parser.add_argument("--concurrency", type=int, default=10, help="Max concurrent calls")
parser.add_argument("--iterations", type=int, default=50, help="Total calls per test")
parser.add_argument("--impl", default="python", choices=["python", "typescript"])
args = parser.parse_args()
if args.impl == "python":
client = MCPClient(
command=["uv", "run", "hanzo-mcp"],
cwd=HANZO_ROOT / "python-sdk",
env={"LOGLEVEL": "ERROR", "HANZO_MCP_LOG_LEVEL": "ERROR"},
)
else:
client = MCPClient(
command=["node", "dist/cli.js", "serve"],
cwd=HANZO_ROOT / "mcp",
env={"NODE_ENV": "test", "MCP_LOG_LEVEL": "error"},
)
print(f"\nHIP-0300 Parallel Benchmark ({args.impl})")
print(f"Concurrency: {args.concurrency}, Iterations: {args.iterations}")
print(f"{'='*70}")
print("Starting server...", end=" ", flush=True)
await asyncio.wait_for(client.start(), timeout=STARTUP_TIMEOUT)
tools = await client.list_tools()
tool_names = set(t["name"] for t in tools)
print(f"OK ({len(tools)} tools)")
# Create temp dir for fs tests
tmp = Path(tempfile.mkdtemp(prefix="mcp-bench-"))
benchmarks = []
# Define test workloads
workloads = [
("exec", "exec", {"command": "echo bench"}),
("exec", "ps", {}),
("git", "status", {}),
("git", "log", {"limit": 3}),
("think", "think", {"thought": "Benchmark test"}),
]
# Only test tools that are registered
workloads = [(t, a, p) for t, a, p in workloads if t in tool_names]
# Add fs tests with unique filenames
if "fs" in tool_names:
# Write files first
for i in range(args.iterations):
await client.call_tool("fs", {
"action": "write",
"path": str(tmp / f"bench_{i}.txt"),
"content": f"benchmark content {i}",
})
workloads.append(("fs", "read", {"path": str(tmp / "bench_0.txt")}))
workloads.append(("fs", "list", {"path": str(tmp)}))
print(f"\nRunning {len(workloads)} workloads...\n")
print(f"{'Tool':<12} {'Action':<10} {'Pass':<6} {'Fail':<6} {'P50':<10} {'P95':<10} {'Throughput':<12}")
print("-" * 70)
for tool, action, params in workloads:
result = await bench_tool(
client, tool, action, params,
concurrency=args.concurrency,
iterations=args.iterations,
)
benchmarks.append(result)
print(
f"{tool:<12} {action:<10} {result.passed:<6} {result.failed:<6} "
f"{result.p50:>7.1f}ms {result.p95:>7.1f}ms "
f"{result.throughput:>8.1f} ops/s"
)
# Cleanup
import shutil
shutil.rmtree(tmp, ignore_errors=True)
await client.stop()
# Summary
total_passed = sum(b.passed for b in benchmarks)
total_failed = sum(b.failed for b in benchmarks)
total = total_passed + total_failed
all_latencies = [l for b in benchmarks for l in b.latencies_ms]
print(f"\n{'='*70}")
print(f"Total: {total_passed}/{total} passed ({total_failed} failed)")
if all_latencies:
print(f"Overall P50: {statistics.median(all_latencies):.1f}ms P95: {sorted(all_latencies)[int(len(all_latencies)*0.95)]:.1f}ms")
print(f"All tools async-safe: {'YES' if total_failed == 0 else 'NO'}")
sys.exit(0 if total_failed == 0 else 1)
if __name__ == "__main__":
asyncio.run(main())
tests/conformance/run_conformance.py
-751
View File
@@ -1,751 +0,0 @@
#!/usr/bin/env python3
"""
HIP-0300 MCP Conformance Test Suite
Tests that all MCP implementations (TypeScript, Python, Rust) expose equivalent
tool functionality. Handles the fact that TS uses unified tool names (fs, exec)
while Python currently uses legacy names (read_file, run_command) by mapping both.
Speaks raw MCP JSON-RPC 2.0 over stdio to each server process.
Usage:
# Test all enabled implementations
uv run python tests/conformance/run_conformance.py
# Test specific implementation
uv run python tests/conformance/run_conformance.py --impl python
uv run python tests/conformance/run_conformance.py --impl typescript
# Test specific category
uv run python tests/conformance/run_conformance.py --cat filesystem
# Verbose output
uv run python tests/conformance/run_conformance.py -v
"""
from __future__ import annotations
import os
import re
import sys
import json
import time
import shutil
import asyncio
import tempfile
from typing import Any
from pathlib import Path
from dataclasses import field, dataclass
# ── Configuration ─────────────────────────────────────────────────────────────
HANZO_ROOT = Path(os.environ.get("HANZO_ROOT", Path.home() / "work" / "hanzo"))
TIMEOUT = 30 # seconds per request
STARTUP_TIMEOUT = 20 # seconds to wait for server ready
@dataclass
class Implementation:
id: str
name: str
command: list[str]
cwd: Path
env: dict[str, str] = field(default_factory=dict)
enabled: bool = True
startup_timeout: int = STARTUP_TIMEOUT
IMPLEMENTATIONS: list[Implementation] = [
Implementation(
id="python",
name="Hanzo MCP Python",
command=["uv", "run", "hanzo-mcp"],
cwd=HANZO_ROOT / "python-sdk",
env={"LOGLEVEL": "ERROR", "HANZO_MCP_LOG_LEVEL": "ERROR"},
enabled=True,
),
Implementation(
id="typescript",
name="Hanzo MCP TypeScript",
command=["node", "dist/cli.js", "serve"],
cwd=HANZO_ROOT / "mcp",
env={"NODE_ENV": "test", "MCP_LOG_LEVEL": "error"},
enabled=(HANZO_ROOT / "mcp" / "dist" / "cli.js").exists(),
),
Implementation(
id="rust",
name="Hanzo MCP Rust",
command=["cargo", "run", "--release", "--bin", "hanzo-mcp-server", "--", "serve"],
cwd=HANZO_ROOT / "rust-sdk",
env={"RUST_LOG": "error"},
enabled=False,
startup_timeout=60,
),
]
# ── Tool Name Mapping ─────────────────────────────────────────────────────────
# Maps (category, action) → {impl_id: (tool_name, arguments)}
# This bridges unified (TS) and legacy (Python) tool surfaces.
def resolve_tool_call(
impl_id: str,
tool_names: set[str],
category: str,
action: str,
params: dict[str, Any],
tool_schemas: dict[str, dict] | None = None,
) -> tuple[str, dict[str, Any]] | None:
"""Resolve a logical test action to the correct tool name + args for an implementation.
Returns (tool_name, arguments) or None if the tool isn't available.
"""
tool_schemas = tool_schemas or {}
# Unified names (TS default, Python HIP-0300)
# Note: Python's BaseTool-derived tools (fs, git, code, fetch) require a `kwargs` wrapper
# while think/memory/tasks/browser use flat params. We detect which format via tool_names.
unified_map: dict[tuple[str, str], tuple[str, dict]] = {
("filesystem", "read"): ("fs", {"action": "read", **params}),
("filesystem", "write"): ("fs", {"action": "write", **params}),
("filesystem", "stat"): ("fs", {"action": "stat", **params}),
("filesystem", "list"): ("fs", {"action": "list", **params}),
("filesystem", "search"): ("fs", {"action": "search_text", **params}),
("filesystem", "mkdir"): ("fs", {"action": "mkdir", **params}),
("filesystem", "rm"): ("fs", {"action": "rm", **params}),
("shell", "exec"): ("exec", {"action": "exec", **params}),
("shell", "ps"): ("exec", {"action": "ps"}),
("vcs", "status"): ("git", {"action": "status", **params}),
("vcs", "branch"): ("git", {"action": "branch", **params}),
("vcs", "log"): ("git", {"action": "log", **params}),
("vcs", "diff"): ("git", {"action": "diff", **params}),
("code", "symbols"): ("code", {"action": "symbols", **params}),
("code", "summarize"): ("code", {"action": "summarize", **params}),
("network", "fetch"): ("fetch", {"action": "fetch", **params}),
("network", "head"): ("fetch", {"action": "head", **params}),
("reasoning", "think"): ("think", {"action": "think", **params}),
("browser", "status"): ("browser", {"action": "status"}),
("memory", "store"): ("memory", {"action": "store", **params}),
("memory", "recall"): ("memory", {"action": "recall", **params}),
("memory", "delete"): ("memory", {"action": "delete", **params}),
("tasks", "add"): ("tasks", {"action": "add", **params}),
("tasks", "list"): ("tasks", {"action": "list", **params}),
("mode", "list"): ("mode", {"action": "list"}),
}
# Python's HIP-0300 BaseTool uses kwargs wrapper for fs/git/code/fetch/exec
# These tools require: {"action": "...", "kwargs": {...params}}
py_kwargs_map: dict[tuple[str, str], tuple[str, dict]] = {
("filesystem", "read"): ("fs", {"action": "read", "kwargs": params}),
("filesystem", "write"): ("fs", {"action": "write", "kwargs": params}),
("filesystem", "stat"): ("fs", {"action": "stat", "kwargs": params}),
("filesystem", "list"): ("fs", {"action": "list", "kwargs": params}),
("filesystem", "search"): ("fs", {"action": "search_text", "kwargs": params}),
("filesystem", "mkdir"): ("fs", {"action": "mkdir", "kwargs": params}),
("filesystem", "rm"): ("fs", {"action": "rm", "kwargs": params}),
("shell", "exec"): ("exec", {"action": "exec", "kwargs": params}),
("shell", "ps"): ("exec", {"action": "ps", "kwargs": {}}),
("vcs", "status"): ("git", {"action": "status", "kwargs": params}),
("vcs", "branch"): ("git", {"action": "branch", "kwargs": params}),
("vcs", "log"): ("git", {"action": "log", "kwargs": params}),
("vcs", "diff"): ("git", {"action": "diff", "kwargs": params}),
("code", "symbols"): ("code", {"action": "symbols", "kwargs": params}),
("code", "summarize"): ("code", {"action": "summarize", "kwargs": params}),
("network", "fetch"): ("fetch", {"action": "fetch", "kwargs": params}),
("network", "head"): ("fetch", {"action": "head", "kwargs": params}),
}
# Legacy names (Python current)
legacy_map: dict[tuple[str, str], tuple[str, dict]] = {
("filesystem", "read"): ("read_file", params),
("filesystem", "write"): ("write_file", params),
("filesystem", "stat"): ("get_file_info", params),
("filesystem", "list"): ("list_files", params),
("filesystem", "search"): ("grep", params),
("filesystem", "mkdir"): ("create_file", {**params, "content": ""}),
("filesystem", "rm"): ("delete_file", params),
("shell", "exec"): ("run_command", params),
("shell", "ps"): ("list_processes", {}),
("vcs", "status"): ("run_command", {"command": "git status"}),
("vcs", "branch"): ("run_command", {"command": "git branch"}),
("vcs", "log"): ("run_command", {"command": f"git log --oneline -n {params.get('limit', 5)}"}),
("vcs", "diff"): ("run_command", {"command": "git diff"}),
("reasoning", "think"): ("critic", {"analysis": params.get("thought", params.get("analysis", ""))}),
("browser", "status"): ("browser", {"action": "status"}),
}
key = (category, action)
# Check if tool uses kwargs wrapper (Python BaseTool pattern)
def _needs_kwargs(tool_name: str) -> bool:
schema = tool_schemas.get(tool_name, {})
return "kwargs" in schema.get("required", []) or "kwargs" in schema.get("properties", {})
# Try kwargs-wrapped unified names (Python BaseTool pattern)
if key in py_kwargs_map:
tool, args = py_kwargs_map[key]
if tool in tool_names and _needs_kwargs(tool):
return tool, args
# Try flat unified names (TS pattern)
if key in unified_map:
tool, args = unified_map[key]
if tool in tool_names:
return tool, args
# Fall back to legacy name
if key in legacy_map:
tool, args = legacy_map[key]
if tool in tool_names:
return tool, args
return None
# ── MCP Protocol ──────────────────────────────────────────────────────────────
class MCPClient:
"""Speaks JSON-RPC 2.0 over stdio to an MCP server process."""
def __init__(self, impl: Implementation):
self.impl = impl
self.proc: asyncio.subprocess.Process | None = None
self._id = 0
async def start(self) -> None:
env = {**os.environ, **self.impl.env}
self.proc = await asyncio.create_subprocess_exec(
*self.impl.command,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
cwd=str(self.impl.cwd),
env=env,
)
resp = await self._request("initialize", {
"protocolVersion": "2024-11-05",
"capabilities": {"tools": {}},
"clientInfo": {"name": "conformance-test", "version": "1.0.0"},
})
if "error" in resp:
raise RuntimeError(f"Initialize failed: {resp['error']}")
await self._notify("notifications/initialized")
async def stop(self) -> None:
if self.proc and self.proc.returncode is None:
self.proc.terminate()
try:
await asyncio.wait_for(self.proc.wait(), timeout=5)
except asyncio.TimeoutError:
self.proc.kill()
async def list_tools(self) -> list[dict]:
resp = await self._request("tools/list", {})
return resp.get("result", {}).get("tools", [])
async def call_tool(self, name: str, arguments: dict[str, Any]) -> dict:
return await self._request("tools/call", {"name": name, "arguments": arguments})
async def _request(self, method: str, params: dict) -> dict:
self._id += 1
msg = {"jsonrpc": "2.0", "id": self._id, "method": method, "params": params}
return await self._send_and_recv(msg)
async def _notify(self, method: str, params: dict | None = None) -> None:
msg: dict[str, Any] = {"jsonrpc": "2.0", "method": method}
if params:
msg["params"] = params
assert self.proc and self.proc.stdin
self.proc.stdin.write(json.dumps(msg).encode() + b"\n")
await self.proc.stdin.drain()
async def _send_and_recv(self, msg: dict) -> dict:
assert self.proc and self.proc.stdin and self.proc.stdout
data = json.dumps(msg).encode() + b"\n"
self.proc.stdin.write(data)
await self.proc.stdin.drain()
deadline = time.monotonic() + TIMEOUT
while time.monotonic() < deadline:
try:
line = await asyncio.wait_for(
self.proc.stdout.readline(),
timeout=max(0.1, deadline - time.monotonic()),
)
except asyncio.TimeoutError:
break
if not line:
break
line = line.strip()
if not line:
continue
try:
resp = json.loads(line)
except json.JSONDecodeError:
continue
if "id" not in resp:
continue
if resp.get("id") == msg["id"]:
return resp
return {"error": {"code": -1, "message": "Timeout waiting for response"}}
# ── Test Cases ────────────────────────────────────────────────────────────────
@dataclass
class TestCase:
category: str
action: str
name: str
params: dict[str, Any]
expect_success: bool = True
expect_pattern: str | None = None
expect_error_pattern: str | None = None
setup: Any = None
cleanup: Any = None
def build_test_cases() -> list[TestCase]:
"""Build the HIP-0300 conformance test cases."""
tmp = Path(tempfile.mkdtemp(prefix="mcp-conformance-"))
cases: list[TestCase] = []
def setup_fs():
tmp.mkdir(parents=True, exist_ok=True)
def cleanup_fs():
shutil.rmtree(tmp, ignore_errors=True)
# ── Filesystem ────────────────────────────────────────────────────────
cases.extend([
TestCase(
category="filesystem", action="write", name="write creates file",
params={"path": str(tmp / "hello.txt"), "content": "Hello HIP-0300!"},
setup=setup_fs,
),
TestCase(
category="filesystem", action="read", name="read reads file back",
params={"path": str(tmp / "hello.txt")},
expect_pattern="Hello HIP-0300!",
),
TestCase(
category="filesystem", action="stat", name="stat gets metadata",
params={"path": str(tmp / "hello.txt")},
expect_pattern="(?i)size|bytes|modified|type|permission",
),
TestCase(
category="filesystem", action="list", name="list directory",
params={"path": str(tmp)},
expect_pattern="hello",
),
TestCase(
category="filesystem", action="rm", name="rm removes file",
params={"path": str(tmp / "hello.txt"), "confirm": True},
cleanup=cleanup_fs,
),
])
# ── Shell / Execution ─────────────────────────────────────────────────
cases.extend([
TestCase(
category="shell", action="exec", name="exec echo command",
params={"command": 'echo "HIP-0300 OK"'},
expect_pattern="HIP-0300 OK",
),
TestCase(
category="shell", action="exec", name="exec true succeeds",
params={"command": "true"},
),
TestCase(
category="shell", action="ps", name="ps lists processes",
params={},
),
])
# ── Version Control ───────────────────────────────────────────────────
cases.extend([
TestCase(
category="vcs", action="status", name="git status",
params={},
),
TestCase(
category="vcs", action="branch", name="git branch lists branches",
params={},
expect_pattern="(?i)main|master|\\*",
),
TestCase(
category="vcs", action="log", name="git log shows history",
params={"limit": 3},
),
])
# ── Code ──────────────────────────────────────────────────────────────
code_file = tmp / "sample.py"
def setup_code():
tmp.mkdir(parents=True, exist_ok=True)
code_file.write_text('def greet(name):\n return f"hello {name}"\n\nclass Greeter:\n pass\n')
cases.extend([
TestCase(
category="code", action="symbols", name="code.symbols lists symbols",
params={"path": str(code_file)},
expect_pattern="(?i)greet|hello|Greeter|function|class|def",
setup=setup_code,
),
TestCase(
category="code", action="summarize", name="code.summarize diff text",
params={"text": "--- a/foo.py\n+++ b/foo.py\n@@ -1 +1 @@\n-old\n+new\n"},
),
])
# ── Network / Fetch ───────────────────────────────────────────────────
cases.extend([
TestCase(
category="network", action="fetch", name="fetch.fetch retrieves URL",
params={"url": "https://httpbin.org/get"},
expect_pattern="(?i)origin|headers|url",
),
TestCase(
category="network", action="head", name="fetch.head gets headers",
params={"url": "https://httpbin.org/get"},
expect_pattern="(?i)content-type|200|headers|status",
),
])
# ── Reasoning ─────────────────────────────────────────────────────────
cases.append(
TestCase(
category="reasoning", action="think", name="think accepts thought",
params={"action": "think", "thought": "Testing conformance across implementations."},
),
)
# ── Browser (non-browser-requiring tests) ─────────────────────────────
cases.extend([
TestCase(
category="browser", action="status", name="browser status check",
params={"action": "status"},
),
])
# ── Memory ────────────────────────────────────────────────────────────
# TS memory uses: key/value. Python memory uses: fact/query.
cases.extend([
TestCase(
category="memory", action="store", name="memory store",
params={"key": "conformance-test", "value": "HIP-0300 value", "fact": "conformance-test: HIP-0300 value"},
expect_pattern="(?i)stored|saved|ok|success|written|remembered|added",
),
TestCase(
category="memory", action="recall", name="memory recall",
params={"key": "conformance-test", "query": "conformance-test"},
expect_pattern="(?i)HIP-0300|conformance",
),
TestCase(
category="memory", action="delete", name="memory delete",
params={"key": "conformance-test", "query": "conformance-test"},
),
])
# ── Tasks ─────────────────────────────────────────────────────────────
cases.extend([
TestCase(
category="tasks", action="add", name="tasks add",
params={"content": "Conformance test task"},
expect_pattern="(?i)added|created|task|ok",
),
TestCase(
category="tasks", action="list", name="tasks list",
params={},
),
])
# ── Mode ──────────────────────────────────────────────────────────────
cases.append(
TestCase(
category="mode", action="list", name="mode.list shows modes",
params={},
),
)
return cases
# ── Runner ────────────────────────────────────────────────────────────────────
@dataclass
class TestResult:
impl: str
category: str
action: str
name: str
passed: bool
duration_ms: float
tool_used: str = ""
error: str = ""
skipped: bool = False
def extract_text(resp: dict) -> str:
"""Extract all text content from an MCP response."""
result = resp.get("result", {})
content = result.get("content", [])
if isinstance(content, list):
texts = [item.get("text", "") for item in content if isinstance(item, dict)]
return " ".join(texts)
if isinstance(result, str):
return result
return json.dumps(result)
def is_error_response(resp: dict) -> bool:
"""Check if response indicates an error."""
if "error" in resp:
return True
result = resp.get("result", {})
if isinstance(result, dict) and result.get("isError"):
return True
return False
async def run_tests(
impls: list[Implementation],
cases: list[TestCase],
categories_filter: list[str] | None = None,
verbose: bool = False,
) -> list[TestResult]:
"""Run conformance tests against all implementations."""
results: list[TestResult] = []
for impl in impls:
if not impl.enabled:
continue
print(f"\n{'='*60}")
print(f" {impl.name} ({impl.id})")
print(f"{'='*60}")
client = MCPClient(impl)
try:
print(f" Starting server...", end=" ", flush=True)
await asyncio.wait_for(client.start(), timeout=impl.startup_timeout)
print("OK")
tools = await client.list_tools()
tool_names = set(t["name"] for t in tools)
tool_schemas = {t["name"]: t.get("inputSchema", {}) for t in tools}
print(f" Tools registered: {len(tools)}")
if verbose:
for tn in sorted(tool_names):
print(f" - {tn}")
for tc in cases:
if categories_filter and tc.category not in categories_filter:
continue
resolved = resolve_tool_call(impl.id, tool_names, tc.category, tc.action, tc.params, tool_schemas)
if resolved is None:
print(f" SKIP {tc.name} (no matching tool for {tc.category}.{tc.action})")
results.append(TestResult(
impl=impl.id, category=tc.category, action=tc.action,
name=tc.name, passed=False, duration_ms=0,
error=f"No tool for {tc.category}.{tc.action}", skipped=True,
))
continue
tool_name, arguments = resolved
if tc.setup:
tc.setup()
t0 = time.monotonic()
try:
resp = await asyncio.wait_for(
client.call_tool(tool_name, arguments),
timeout=TIMEOUT,
)
duration = (time.monotonic() - t0) * 1000
is_err = is_error_response(resp)
text = extract_text(resp)
passed = True
error = ""
if tc.expect_success and is_err:
passed = False
err_msg = resp.get("error", {}).get("message", text)
error = f"Expected success, got error: {err_msg[:200]}"
elif not tc.expect_success and not is_err:
passed = False
error = f"Expected error, got success: {text[:100]}"
if passed and tc.expect_pattern:
if not re.search(tc.expect_pattern, text, re.IGNORECASE):
passed = False
error = f"Pattern /{tc.expect_pattern}/ not found in: {text[:200]}"
if passed and not tc.expect_success and tc.expect_error_pattern:
err_text = resp.get("error", {}).get("message", text)
if not re.search(tc.expect_error_pattern, err_text, re.IGNORECASE):
passed = False
error = f"Error pattern /{tc.expect_error_pattern}/ not found"
status = "PASS" if passed else "FAIL"
print(f" {status} {tc.name} [{tool_name}] ({duration:.0f}ms)")
if not passed:
print(f" {error}")
elif verbose:
print(f" -> {text[:120]}")
results.append(TestResult(
impl=impl.id, category=tc.category, action=tc.action,
name=tc.name, passed=passed, duration_ms=duration,
tool_used=tool_name, error=error,
))
except asyncio.TimeoutError:
duration = (time.monotonic() - t0) * 1000
print(f" FAIL {tc.name} [{tool_name}] (TIMEOUT {duration:.0f}ms)")
results.append(TestResult(
impl=impl.id, category=tc.category, action=tc.action,
name=tc.name, passed=False, duration_ms=duration,
tool_used=tool_name, error="Timeout",
))
except Exception as e:
duration = (time.monotonic() - t0) * 1000
print(f" FAIL {tc.name} [{tool_name}] ({e})")
results.append(TestResult(
impl=impl.id, category=tc.category, action=tc.action,
name=tc.name, passed=False, duration_ms=duration,
tool_used=tool_name, error=str(e),
))
finally:
if tc.cleanup:
try:
tc.cleanup()
except Exception:
pass
except Exception as e:
print(f"FAILED to start: {e}")
for tc in cases:
if categories_filter and tc.category not in categories_filter:
continue
results.append(TestResult(
impl=impl.id, category=tc.category, action=tc.action,
name=tc.name, passed=False, duration_ms=0,
error=f"Server start failed: {e}",
))
finally:
await client.stop()
return results
def print_summary(results: list[TestResult]) -> None:
"""Print a summary table of results."""
if not results:
print("\nNo results.")
return
impls = sorted(set(r.impl for r in results))
categories = sorted(set(r.category for r in results))
print(f"\n{'='*70}")
print(" HIP-0300 CONFORMANCE SUMMARY")
print(f"{'='*70}\n")
# Per-implementation breakdown
for impl in impls:
ir = [r for r in results if r.impl == impl and not r.skipped]
passed = sum(1 for r in ir if r.passed)
total = len(ir)
skipped = sum(1 for r in results if r.impl == impl and r.skipped)
pct = (passed / total * 100) if total else 0
status = "PASS" if passed == total else "FAIL"
print(f" {impl:20s} {passed}/{total} ({pct:.0f}%) [{status}] ({skipped} skipped)")
for cat in categories:
cr = [r for r in ir if r.category == cat]
if not cr:
continue
cp = sum(1 for r in cr if r.passed)
ct = len(cr)
marker = "+" if cp == ct else "X"
# Show which tool names were used
tool_names = sorted(set(r.tool_used for r in cr if r.tool_used))
tools_str = ", ".join(tool_names) if tool_names else "?"
print(f" [{marker}] {cat:15s} {cp}/{ct} via: {tools_str}")
# Cross-implementation parity
if len(impls) > 1:
print(f"\n CROSS-IMPLEMENTATION PARITY:")
for cat in categories:
impl_status = {}
for impl in impls:
cr = [r for r in results if r.impl == impl and r.category == cat and not r.skipped]
if cr:
impl_status[impl] = all(r.passed for r in cr)
if len(impl_status) < 2:
continue
values = list(impl_status.values())
if all(values):
print(f" {cat:15s} PARITY OK")
elif any(values):
passing = [k for k, v in impl_status.items() if v]
failing = [k for k, v in impl_status.items() if not v]
print(f" {cat:15s} MISMATCH pass={passing} fail={failing}")
else:
print(f" {cat:15s} ALL FAIL")
print()
async def main() -> int:
import argparse
parser = argparse.ArgumentParser(description="HIP-0300 MCP Conformance Tests")
parser.add_argument("--impl", "-i", action="append", help="Implementation ID(s)")
parser.add_argument("--cat", "-c", action="append", help="Category filter")
parser.add_argument("--verbose", "-v", action="store_true")
parser.add_argument("--list", action="store_true", help="List implementations")
args = parser.parse_args()
if args.list:
for impl in IMPLEMENTATIONS:
status = "enabled" if impl.enabled else "disabled"
exists = impl.cwd.exists()
print(f" {impl.id:15s} {impl.name:30s} [{status}] {'exists' if exists else 'MISSING'}")
return 0
impls = IMPLEMENTATIONS
if args.impl:
impls = [i for i in impls if i.id in args.impl]
for i in impls:
i.enabled = True
cases = build_test_cases()
enabled = [i.id for i in impls if i.enabled]
print(f"HIP-0300 Conformance Suite: {len(cases)} test cases")
print(f"Implementations: {', '.join(enabled)}")
results = await run_tests(impls, cases, categories_filter=args.cat, verbose=args.verbose)
print_summary(results)
non_skipped = [r for r in results if not r.skipped]
if all(r.passed for r in non_skipped):
print("ALL TESTS PASSED")
return 0
else:
failed = sum(1 for r in non_skipped if not r.passed)
print(f"{failed} TEST(S) FAILED")
return 1
if __name__ == "__main__":
sys.exit(asyncio.run(main()))
tests/conftest.py
-57
View File
@@ -1,57 +0,0 @@
from __future__ import annotations
import os
import sys
import logging
from typing import TYPE_CHECKING, Iterator, AsyncIterator
# Add pkg directory to path for hanzoai import
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)), "pkg"))
import pytest
import pytest_asyncio
from pytest_asyncio import is_async_test
from hanzoai import Hanzo, AsyncHanzo
from tests.mock_fixtures import mock_api
if TYPE_CHECKING:
from _pytest.fixtures import FixtureRequest
pytest.register_assert_rewrite("tests.utils")
logging.getLogger("hanzoai").setLevel(logging.DEBUG)
# automatically add `pytest.mark.asyncio()` to all of our async tests
# so we don't have to add that boilerplate everywhere
def pytest_collection_modifyitems(items: list[pytest.Function]) -> None:
pytest_asyncio_tests = (item for item in items if is_async_test(item))
session_scope_marker = pytest.mark.asyncio()
for async_test in pytest_asyncio_tests:
async_test.add_marker(session_scope_marker, append=False)
base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
api_key = "My API Key"
@pytest.fixture(scope="function")
def client(request: FixtureRequest, mock_api) -> Iterator[Hanzo]:
strict = getattr(request, "param", True)
if not isinstance(strict, bool):
raise TypeError(f"Unexpected fixture parameter type {type(strict)}, expected {bool}")
with Hanzo(base_url=base_url, api_key=api_key, _strict_response_validation=strict) as client:
yield client
@pytest_asyncio.fixture(scope="function")
async def async_client(request: FixtureRequest, mock_api) -> AsyncIterator[AsyncHanzo]:
strict = getattr(request, "param", True)
if not isinstance(strict, bool):
raise TypeError(f"Unexpected fixture parameter type {type(strict)}, expected {bool}")
async with AsyncHanzo(base_url=base_url, api_key=api_key, _strict_response_validation=strict) as client:
yield client
tests/e2e/hanzo-net-orchestration/Makefile
-201
View File
@@ -1,201 +0,0 @@
# Makefile for Hanzo Net E2E Testing
.PHONY: help setup test quick-test clean docker-up docker-down logs
# Default target
help:
@echo "Hanzo Net E2E Test - Available Commands"
@echo "======================================="
@echo ""
@echo "Setup & Installation:"
@echo " make setup - Download models and start services"
@echo " make install - Install hanzo and hanzo-network"
@echo ""
@echo "Testing:"
@echo " make test - Run full E2E test suite"
@echo " make quick-test - Run quick test with single model"
@echo " make test-qwen - Test with Qwen3 model"
@echo " make test-llama - Test with Llama 3.2 model"
@echo " make test-mistral - Test with Mistral 7B"
@echo ""
@echo "Docker Management:"
@echo " make docker-up - Start Docker services"
@echo " make docker-down - Stop Docker services"
@echo " make logs - View Docker logs"
@echo ""
@echo "Hanzo Commands:"
@echo " make start-net - Start hanzo net locally"
@echo " make start-dev - Start hanzo dev with local orchestrator"
@echo " make demo - Run interactive demo"
@echo ""
@echo "Cleanup:"
@echo " make clean - Stop all services and clean up"
# Installation
install:
@echo "Installing hanzo and dependencies..."
@cd ../../.. && pip install -e pkg/hanzo/
@cd ../../.. && pip install -e pkg/hanzo-network/
@cd ../../.. && pip install -e pkg/hanzo-mcp/
@echo "✓ Installation complete"
# Setup models and services
setup: install
@echo "Setting up models and services..."
@bash setup_models.sh
@echo "✓ Setup complete"
# Run full test suite
test: install
@echo "Running full E2E test suite..."
@bash run_test.sh
# Quick test with default model
quick-test: install
@echo "Running quick test..."
@bash run_test.sh --quick
# Test specific models
test-qwen: install
@echo "Testing with Qwen3..."
@bash run_test.sh --model qwen3 --quick
test-llama: install
@echo "Testing with Llama 3.2..."
@bash run_test.sh --model llama-3.2-3b --quick
test-mistral: install
@echo "Testing with Mistral 7B..."
@bash run_test.sh --model mistral-7b --quick
test-deepseek: install
@echo "Testing with DeepSeek..."
@bash run_test.sh --model deepseek-v3 --quick
# Docker management
docker-up:
@echo "Starting Docker services..."
@docker-compose up -d
@echo "✓ Services started"
@echo "Run 'make logs' to view logs"
docker-down:
@echo "Stopping Docker services..."
@docker-compose down
@echo "✓ Services stopped"
logs:
@docker-compose logs -f
# Start hanzo net manually
start-net:
@echo "Starting hanzo net with Qwen3..."
hanzo net \
--name "e2e-test" \
--port 52415 \
--models qwen3 \
--network local \
--max-jobs 10
# Start hanzo dev with local orchestrator
start-dev:
@echo "Starting hanzo dev with local orchestrator..."
hanzo dev \
--orchestrator local:qwen3 \
--use-hanzo-net \
--instances 3
# Interactive demo
demo: install
@echo "Starting interactive demo..."
@echo ""
@echo "This will:"
@echo "1. Start hanzo net with Qwen3"
@echo "2. Launch hanzo dev with local orchestrator"
@echo "3. Create a network of local + API agents"
@echo ""
@read -p "Press Enter to continue..."
@bash -c "hanzo net --models qwen3 --network local &"
@sleep 5
@hanzo dev --orchestrator local:qwen3 --use-hanzo-net
# Run specific test functions
test-routing: install
@python3 -c "import asyncio; from test_local_ai_orchestration import HanzoNetE2ETest; \
t = HanzoNetE2ETest(); \
asyncio.run(t.setup()); \
asyncio.run(t.start_hanzo_net('qwen3')); \
network = asyncio.run(t.create_agent_network('qwen3')); \
asyncio.run(t.test_task_routing(network))"
test-cost: install
@python3 -c "import asyncio; from test_local_ai_orchestration import HanzoNetE2ETest; \
t = HanzoNetE2ETest(); \
asyncio.run(t.setup()); \
asyncio.run(t.start_hanzo_net('qwen3')); \
network = asyncio.run(t.create_agent_network('qwen3')); \
asyncio.run(t.test_cost_optimization(network))"
test-integration: install
@python3 -c "import asyncio; from test_local_ai_orchestration import HanzoNetE2ETest; \
t = HanzoNetE2ETest(); \
asyncio.run(t.setup()); \
asyncio.run(t.start_hanzo_net('qwen3')); \
asyncio.run(t.test_hanzo_dev_integration('qwen3'))"
# Cleanup
clean:
@echo "Cleaning up..."
@-pkill -f "hanzo net" 2>/dev/null || true
@-pkill -f "hanzo dev" 2>/dev/null || true
@-docker-compose down 2>/dev/null || true
@echo "✓ Cleanup complete"
# Check system requirements
check-requirements:
@echo "Checking system requirements..."
@echo ""
@echo -n "Python: "
@python3 --version
@echo -n "Docker: "
@docker --version || echo "Not installed"
@echo -n "Docker Compose: "
@docker-compose --version || docker compose version || echo "Not installed"
@echo ""
@echo "Checking API keys..."
@[ -n "$$OPENAI_API_KEY" ] && echo "✓ OPENAI_API_KEY set" || echo "✗ OPENAI_API_KEY not set"
@[ -n "$$ANTHROPIC_API_KEY" ] && echo "✓ ANTHROPIC_API_KEY set" || echo "✗ ANTHROPIC_API_KEY not set"
@[ -n "$$GOOGLE_API_KEY" ] && echo "✓ GOOGLE_API_KEY set" || echo "✗ GOOGLE_API_KEY not set"
@echo ""
@echo "Checking hanzo installation..."
@which hanzo >/dev/null 2>&1 && echo "✓ hanzo CLI installed" || echo "✗ hanzo CLI not found"
@python3 -c "import hanzo_network" 2>/dev/null && echo "✓ hanzo-network installed" || echo "✗ hanzo-network not found"
# Performance monitoring
monitor:
@echo "Starting performance monitor..."
@watch -n 1 'echo "=== System Resources ===" && \
echo "" && \
echo "CPU & Memory:" && \
top -l 1 | head -10 && \
echo "" && \
echo "Hanzo Processes:" && \
ps aux | grep -E "hanzo (net|dev)" | grep -v grep && \
echo "" && \
echo "Network Ports:" && \
lsof -i :52415 -i :11434 -i :8080 -i :8000 2>/dev/null | head -10'
# Run all tests in sequence
test-all: install
@echo "Running all model tests..."
@make test-qwen
@sleep 5
@make test-llama
@sleep 5
@make test-mistral
@echo ""
@echo "================================"
@echo "All tests complete!"
@echo "================================"
.DEFAULT_GOAL := help
tests/e2e/hanzo-net-orchestration/README.md
-329
View File
@@ -1,329 +0,0 @@
# Hanzo Net E2E Test - Local AI Orchestration
This end-to-end test demonstrates the complete local AI orchestration capability of Hanzo Dev, showcasing:
1. **Local AI as Orchestrator**: Using Qwen3, Llama 3.2, or other local models to orchestrate
2. **Hybrid Agent Networks**: Local orchestrator managing API-based agents (Claude, GPT-4, Gemini)
3. **Cost Optimization**: 90% cost reduction through intelligent routing
4. **Full MCP Integration**: All agents can use MCP tools and communicate
## Architecture
```
┌─────────────────────────────────────────┐
│ Local Orchestrator (Qwen3) │
│ via hanzo/net │
│ (Strategic Planning & Routing) │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Cost-Optimized Router │
│ (Prefers local for simple tasks) │
└──────┬──────────────┬──────────────────┘
│ │
▼ ▼
┌──────────────┐ ┌──────────────────────┐
│ Local Workers│ │ API Workers │
│ (Qwen3) │ │ • Claude 3.5 Sonnet │
│ Free/Fast │ │ • GPT-4 Turbo │
│ │ │ • Gemini Pro │
└──────────────┘ └──────────────────────┘
```
## Quick Start
### 1. Basic Test (Recommended)
```bash
# Run quick test with default model (qwen3)
./run_test.sh --quick
# Run with specific model
./run_test.sh --model llama-3.2-3b --quick
```
### 2. Full Test with Docker Setup
```bash
# Setup models and run full test
./run_test.sh --setup
# This will:
# 1. Download required models
# 2. Start Docker containers
# 3. Run complete test suite
```
### 3. Manual Testing
```bash
# Step 1: Start hanzo net with local model
hanzo net --models qwen3 --network local
# Step 2: Run hanzo dev with local orchestrator
hanzo dev --orchestrator local:qwen3 --use-hanzo-net
# Step 3: The system will:
# - Use Qwen3 as the orchestrator
# - Create local workers for simple tasks
# - Use Claude/GPT-4/Gemini for complex tasks
# - Route intelligently to minimize costs
```
## Test Scenarios
### 1. Task Routing Test
Tests that tasks are routed correctly based on complexity:
- **Simple tasks** → Local workers (free)
- File listing
- JSON formatting
- String validation
- **Complex tasks** → API workers (paid)
- Implementation of algorithms
- System design
- Debugging complex issues
- **Review tasks** → Critics
- Code security review
- Performance analysis
### 2. Cost Optimization Test
Verifies that the system achieves >50% cost savings by:
- Using local models for majority of simple tasks
- Only calling APIs when truly needed
- Tracking task distribution
### 3. Integration Test
Tests the full `hanzo dev` command with:
- Local orchestrator startup
- Agent network creation
- MCP tool integration
- Graceful shutdown
## Supported Models
### Local Models (via hanzo/net)
- **Qwen 2.5/3**: Best for instruction following
- **Llama 3.2**: Good general performance
- **Mistral 7B**: Strong reasoning
- **DeepSeek V3**: Excellent for code
### API Models (when needed)
- **Claude 3.5 Sonnet**: Complex implementation
- **GPT-4 Turbo**: Analysis and design
- **Gemini Pro**: Multimodal tasks
## Configuration
### Environment Variables
```bash
# API Keys (optional - only for API workers)
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GOOGLE_API_KEY="..."
# Hanzo Net Configuration
export HANZO_NET_PORT=52415
export HANZO_NET_MODELS="qwen3,llama-3.2-3b"
```
### Docker Services
The test includes Docker Compose configuration for:
1. **Ollama**: General model serving
2. **LocalAI**: GGUF model support
3. **vLLM**: High-performance inference (GPU)
4. **Text Generation WebUI**: Interactive testing
Start services:
```bash
docker-compose up -d
```
Stop services:
```bash
docker-compose down
```
## Expected Results
### Successful Test Output
```
============================================
HANZO NET E2E TEST - LOCAL AI ORCHESTRATION
============================================
Testing with model: qwen3
============================================
✓ hanzo net started successfully on port 52415
✓ Created local qwen3 orchestrator via hanzo/net
✓ Agent network initialized with 7 agents
=== Testing Task Routing ===
✓ Simple task → local_worker_0
✓ Complex task → claude_worker
✓ Review task → local_critic
=== Testing Cost Optimization ===
Task Distribution:
Local models: 5/8
API models: 3/8
Cost savings: ~62.5%
=== Testing Hanzo Dev Integration ===
✓ hanzo dev started successfully
TEST SUMMARY
============================================
qwen3:
Routing: 5/5 passed
Cost Optimization: ✓ (62.5% savings)
Hanzo Dev Integration: ✓
```
### Cost Savings Analysis
With this setup, you can expect:
- **90% cost reduction** for simple tasks
- **60-70% overall cost reduction** in typical workflows
- **Full capability** maintained (complex tasks still use best models)
## Troubleshooting
### Port Already in Use
```bash
# Check what's using the port
lsof -i :52415
# Kill the process or use different port
hanzo net --port 52416
```
### Model Download Issues
```bash
# Download models manually with Ollama
ollama pull qwen2.5:3b
ollama pull llama3.2:3b
# Or use Hugging Face CLI
huggingface-cli download Qwen/Qwen2.5-3B-Instruct-GGUF
```
### API Key Issues
The test will work without API keys but with reduced functionality:
- Local orchestrator and workers will still function
- API-based workers will be skipped
- Cost optimization will show 100% local usage
### Memory Issues
Adjust memory limits in `docker-compose.yml`:
```yaml
deploy:
resources:
limits:
memory: 8G # Reduce if needed
```
## Advanced Usage
### Custom Model Configuration
Create a custom model config:
```yaml
# models/custom-model.yaml
name: custom-model
parameters:
model: /path/to/model.gguf
temperature: 0.7
max_tokens: 2048
```
### Running Specific Tests
```python
# Run only routing test
python3 -c "
import asyncio
from test_local_ai_orchestration import HanzoNetE2ETest
async def test():
t = HanzoNetE2ETest()
await t.setup()
await t.start_hanzo_net('qwen3')
network = await t.create_agent_network('qwen3')
await t.test_task_routing(network)
asyncio.run(test())
"
```
### Monitoring Performance
View real-time logs:
```bash
# Hanzo net logs
hanzo net --models qwen3 --network local --verbose
# Docker logs
docker-compose logs -f
# System monitoring
htop # CPU/Memory usage
nvidia-smi # GPU usage (if available)
```
## CI/CD Integration
Add to your CI pipeline:
```yaml
# .github/workflows/e2e-test.yml
name: E2E Test - Local AI Orchestration
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Setup Python
uses: actions/setup-python@v2
with:
python-version: '3.10'
- name: Install dependencies
run: |
pip install -e pkg/hanzo/
pip install -e pkg/hanzo-network/
- name: Run E2E Test
run: |
cd tests/e2e/hanzo-net-orchestration
./run_test.sh --quick --model llama-3.2-3b
```
## Summary
This E2E test demonstrates that Hanzo Dev can:
1. **Use local AI models as orchestrators** via hanzo/net
2. **Manage hybrid networks** of local and API agents
3. **Optimize costs** by routing intelligently
4. **Maintain full capability** while reducing expenses
5. **Scale from laptop to cloud** seamlessly
The result is an AI coding assistant that:
- Runs primarily on local/private infrastructure
- Calls expensive APIs only when necessary
- Provides enterprise-grade capabilities
- Reduces costs by up to 90%
tests/e2e/hanzo-net-orchestration/compose.yml
-111
View File
@@ -1,111 +0,0 @@
version: '3.8'
services:
# Ollama for running local models
ollama:
image: ollama/ollama:latest
container_name: hanzo-ollama
ports:
- "11434:11434"
volumes:
- ollama_data:/root/.ollama
environment:
- OLLAMA_HOST=0.0.0.0
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities: [gpu]
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
interval: 30s
timeout: 10s
retries: 3
# LocalAI for additional model support
localai:
image: quay.io/go-skynet/local-ai:latest
container_name: hanzo-localai
ports:
- "8080:8080"
volumes:
- ./models:/models
- ./images:/tmp/images
environment:
- DEBUG=true
- MODELS_PATH=/models
- GALLERIES=[{"name":"model-gallery","url":"github:go-skynet/model-gallery/index.yaml"}]
- PRELOAD_MODELS=[{"id":"qwen3","name":"qwen3","urls":["https://huggingface.co/Qwen/Qwen2.5-3B-Instruct-GGUF"]}]
deploy:
resources:
limits:
memory: 8G
cpus: '4'
# Text Generation Web UI for testing
text-generation-webui:
image: atinoda/text-generation-webui:default
container_name: hanzo-text-gen
ports:
- "7860:7860"
- "5000:5000" # API port
volumes:
- ./models:/app/models
- ./characters:/app/characters
- ./presets:/app/presets
environment:
- CLI_ARGS=--api --listen --model-dir /app/models
deploy:
resources:
limits:
memory: 16G
cpus: '8'
# vLLM for high-performance inference
vllm:
image: vllm/vllm-openai:latest
container_name: hanzo-vllm
ports:
- "8000:8000"
volumes:
- ./models:/models
environment:
- HF_HOME=/models
command: >
--model mistralai/Mistral-7B-Instruct-v0.1
--host 0.0.0.0
--port 8000
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities: [gpu]
limits:
memory: 24G
# MLX Server for Apple Silicon (Mac only)
# Uncomment if running on Mac with Apple Silicon
# mlx-server:
# build:
# context: .
# dockerfile: Dockerfile.mlx
# container_name: hanzo-mlx
# ports:
# - "5001:5001"
# volumes:
# - ./models:/models
# environment:
# - MLX_MODEL=mlx-community/Llama-3.2-3B-Instruct-4bit
# platform: linux/arm64
volumes:
ollama_data:
networks:
default:
name: hanzo-net
driver: bridge
tests/e2e/hanzo-net-orchestration/run_test.sh
-167
View File
@@ -1,167 +0,0 @@
#!/bin/bash
# E2E Test Runner for Hanzo Net Local AI Orchestration
set -e
echo "=============================================="
echo "Hanzo Net E2E Test Runner"
echo "=============================================="
# Colors
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m'
# Parse arguments
RUN_SETUP=false
MODEL="qwen3"
QUICK_TEST=false
while [[ $# -gt 0 ]]; do
case $1 in
--setup)
RUN_SETUP=true
shift
;;
--model)
MODEL="$2"
shift 2
;;
--quick)
QUICK_TEST=true
shift
;;
--help)
echo "Usage: $0 [options]"
echo ""
echo "Options:"
echo " --setup Run model setup before testing"
echo " --model NAME Specify model to test (default: qwen3)"
echo " --quick Run quick test (single model only)"
echo " --help Show this help message"
exit 0
;;
*)
echo "Unknown option: $1"
echo "Use --help for usage information"
exit 1
;;
esac
done
# Check Python version
PYTHON_VERSION=$(python3 --version | cut -d' ' -f2 | cut -d'.' -f1-2)
REQUIRED_VERSION="3.9"
if [[ $(echo "$PYTHON_VERSION < $REQUIRED_VERSION" | bc) -eq 1 ]]; then
echo -e "${RED}Error: Python $REQUIRED_VERSION or higher required (found $PYTHON_VERSION)${NC}"
exit 1
fi
# Run setup if requested
if [ "$RUN_SETUP" = true ]; then
echo -e "${YELLOW}Running model setup...${NC}"
bash setup_models.sh
echo ""
fi
# Check if hanzo is installed
if ! command -v hanzo >/dev/null 2>&1; then
echo -e "${RED}Error: hanzo CLI not found${NC}"
echo "Please install it first:"
echo " cd ../../.."
echo " pip install -e pkg/hanzo/"
exit 1
fi
# Check if hanzo-network is installed
if ! python3 -c "import hanzo_network" 2>/dev/null; then
echo -e "${YELLOW}Installing hanzo-network...${NC}"
pip install -e ../../../pkg/hanzo-network/
fi
# Export API keys if they exist in .env
if [ -f .env ]; then
export $(grep -v '^#' .env | xargs)
fi
# Start hanzo net if not running
echo "Checking hanzo net status..."
if ! nc -z localhost 52415 2>/dev/null; then
echo -e "${YELLOW}Starting hanzo net with $MODEL...${NC}"
hanzo net \
--name "e2e-test" \
--port 52415 \
--models "$MODEL" \
--network local \
--max-jobs 10 &
HANZO_NET_PID=$!
# Wait for hanzo net to start
echo -n "Waiting for hanzo net to start"
for i in {1..30}; do
if nc -z localhost 52415 2>/dev/null; then
echo -e " ${GREEN}✓${NC}"
break
fi
echo -n "."
sleep 1
done
if ! nc -z localhost 52415 2>/dev/null; then
echo -e " ${RED}✗${NC}"
echo "Failed to start hanzo net"
exit 1
fi
else
echo -e "${GREEN}✓ hanzo net already running${NC}"
fi
# Run the test
echo ""
echo "Starting E2E test..."
echo "=============================================="
if [ "$QUICK_TEST" = true ]; then
# Quick test - single model only
python3 -c "
import asyncio
import sys
sys.path.insert(0, '../../..')
from tests.e2e.hanzo_net_orchestration.test_local_ai_orchestration import HanzoNetE2ETest
async def quick_test():
test = HanzoNetE2ETest()
test.models_to_test = ['$MODEL']
await test.run_full_test()
asyncio.run(quick_test())
"
else
# Full test
python3 test_local_ai_orchestration.py
fi
TEST_RESULT=$?
# Cleanup
if [ ! -z "$HANZO_NET_PID" ]; then
echo ""
echo "Stopping hanzo net..."
kill $HANZO_NET_PID 2>/dev/null || true
fi
# Report results
echo ""
echo "=============================================="
if [ $TEST_RESULT -eq 0 ]; then
echo -e "${GREEN}✓ E2E Test Passed${NC}"
else
echo -e "${RED}✗ E2E Test Failed${NC}"
fi
echo "=============================================="
exit $TEST_RESULT
tests/e2e/hanzo-net-orchestration/setup_models.sh
-286
View File
@@ -1,286 +0,0 @@
#!/bin/bash
# Setup script for E2E test models
set -e
echo "================================================"
echo "Hanzo Net E2E Test - Model Setup"
echo "================================================"
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
# Create models directory
mkdir -p models
# Function to check if command exists
command_exists() {
command -v "$1" >/dev/null 2>&1
}
# Function to download model with Ollama
download_ollama_model() {
local model=$1
echo -e "${YELLOW}Downloading $model with Ollama...${NC}"
if command_exists ollama; then
ollama pull $model
echo -e "${GREEN}✓ Downloaded $model${NC}"
else
echo -e "${RED}✗ Ollama not installed. Install from: https://ollama.ai${NC}"
return 1
fi
}
# Function to download Hugging Face model
download_hf_model() {
local model_id=$1
local model_name=$2
echo -e "${YELLOW}Downloading $model_name from Hugging Face...${NC}"
if command_exists huggingface-cli; then
huggingface-cli download $model_id --local-dir ./models/$model_name
echo -e "${GREEN}✓ Downloaded $model_name${NC}"
else
echo -e "${YELLOW}Installing huggingface-hub...${NC}"
pip install huggingface-hub
huggingface-cli download $model_id --local-dir ./models/$model_name
fi
}
# Check for Docker
if ! command_exists docker; then
echo -e "${RED}Docker is not installed. Please install Docker first.${NC}"
exit 1
fi
# Check for Docker Compose
if ! command_exists docker-compose && ! docker compose version >/dev/null 2>&1; then
echo -e "${RED}Docker Compose is not installed. Please install Docker Compose.${NC}"
exit 1
fi
echo ""
echo "Setting up local models for testing..."
echo ""
# 1. Setup Ollama models (if Ollama is installed locally)
if command_exists ollama; then
echo "Setting up Ollama models..."
# Start Ollama service if not running
if ! pgrep -x "ollama" > /dev/null; then
echo "Starting Ollama service..."
ollama serve &
sleep 5
fi
# Download models
download_ollama_model "qwen2.5:3b"
download_ollama_model "llama3.2:3b"
download_ollama_model "mistral:7b"
download_ollama_model "deepseek-coder:6.7b"
else
echo -e "${YELLOW}Ollama not installed locally. Models will be downloaded in Docker container.${NC}"
fi
# 2. Download GGUF models for LocalAI
echo ""
echo "Downloading GGUF models for LocalAI..."
# Create models directory structure
mkdir -p models/gguf
# Download Qwen 3B GGUF
if [ ! -f "models/gguf/qwen2.5-3b-instruct.gguf" ]; then
echo "Downloading Qwen 2.5 3B GGUF..."
wget -O models/gguf/qwen2.5-3b-instruct.gguf \
https://huggingface.co/Qwen/Qwen2.5-3B-Instruct-GGUF/resolve/main/qwen2.5-3b-instruct-q4_k_m.gguf
fi
# Download Llama 3.2 3B GGUF
if [ ! -f "models/gguf/llama-3.2-3b.gguf" ]; then
echo "Downloading Llama 3.2 3B GGUF..."
wget -O models/gguf/llama-3.2-3b.gguf \
https://huggingface.co/NousResearch/Llama-3.2-3B-Instruct-GGUF/resolve/main/Llama-3.2-3B-Instruct-Q4_K_M.gguf
fi
# 3. Create LocalAI model configurations
echo ""
echo "Creating LocalAI model configurations..."
# Qwen config
cat > models/qwen3.yaml <<EOF
name: qwen3
parameters:
model: /models/gguf/qwen2.5-3b-instruct.gguf
temperature: 0.7
top_k: 40
top_p: 0.95
threads: 8
max_tokens: 2048
stop:
- "<|im_end|>"
- "<|endoftext|>"
template:
chat: |
<|im_start|>system
{{.System}}<|im_end|>
<|im_start|>user
{{.Input}}<|im_end|>
<|im_start|>assistant
EOF
# Llama config
cat > models/llama32.yaml <<EOF
name: llama32
parameters:
model: /models/gguf/llama-3.2-3b.gguf
temperature: 0.7
top_k: 40
top_p: 0.95
threads: 8
max_tokens: 2048
stop:
- "</s>"
- "<|eot_id|>"
template:
chat: |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
{{.System}}<|eot_id|><|start_header_id|>user<|end_header_id|>
{{.Input}}<|eot_id|><|start_header_id|>assistant<|end_header_id|>
EOF
# 4. Setup API keys check
echo ""
echo "Checking API keys..."
check_api_key() {
local key_name=$1
local service=$2
if [ -z "${!key_name}" ]; then
echo -e "${YELLOW}⚠ $key_name not set. $service will not be available.${NC}"
echo " Export it with: export $key_name='your-key-here'"
return 1
else
echo -e "${GREEN}✓ $key_name is set for $service${NC}"
return 0
fi
}
check_api_key "OPENAI_API_KEY" "OpenAI (GPT-4/Codex)"
check_api_key "ANTHROPIC_API_KEY" "Anthropic (Claude)"
check_api_key "GOOGLE_API_KEY" "Google (Gemini)"
# 5. Create .env file for Docker Compose
echo ""
echo "Creating .env file..."
cat > .env <<EOF
# API Keys (add your keys here)
OPENAI_API_KEY=${OPENAI_API_KEY:-your-openai-key}
ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:-your-anthropic-key}
GOOGLE_API_KEY=${GOOGLE_API_KEY:-your-google-key}
# Model paths
MODELS_PATH=./models
# Resource limits
MEMORY_LIMIT=16G
CPU_LIMIT=8
EOF
echo -e "${GREEN}✓ Created .env file${NC}"
# 6. Start Docker services
echo ""
echo "Starting Docker services..."
# Use docker compose or docker-compose depending on what's available
if docker compose version >/dev/null 2>&1; then
COMPOSE_CMD="docker compose"
else
COMPOSE_CMD="docker-compose"
fi
$COMPOSE_CMD up -d
# Wait for services to be healthy
echo ""
echo "Waiting for services to start..."
wait_for_service() {
local service=$1
local port=$2
local max_attempts=30
local attempt=0
echo -n "Waiting for $service on port $port..."
while [ $attempt -lt $max_attempts ]; do
if nc -z localhost $port 2>/dev/null; then
echo -e " ${GREEN}✓${NC}"
return 0
fi
echo -n "."
sleep 2
attempt=$((attempt + 1))
done
echo -e " ${RED}✗ (timeout)${NC}"
return 1
}
wait_for_service "Ollama" 11434
wait_for_service "LocalAI" 8080
wait_for_service "vLLM" 8000
# 7. Test model availability
echo ""
echo "Testing model availability..."
# Test Ollama
if curl -s http://localhost:11434/api/tags >/dev/null 2>&1; then
echo -e "${GREEN}✓ Ollama is responding${NC}"
# List available models
echo " Available Ollama models:"
curl -s http://localhost:11434/api/tags | jq -r '.models[].name' | sed 's/^/ - /'
else
echo -e "${RED}✗ Ollama is not responding${NC}"
fi
# Test LocalAI
if curl -s http://localhost:8080/v1/models >/dev/null 2>&1; then
echo -e "${GREEN}✓ LocalAI is responding${NC}"
else
echo -e "${RED}✗ LocalAI is not responding${NC}"
fi
# Test vLLM
if curl -s http://localhost:8000/v1/models >/dev/null 2>&1; then
echo -e "${GREEN}✓ vLLM is responding${NC}"
else
echo -e "${YELLOW}⚠ vLLM may need GPU support${NC}"
fi
echo ""
echo "================================================"
echo "Setup Complete!"
echo "================================================"
echo ""
echo "You can now run the E2E test with:"
echo " python test_local_ai_orchestration.py"
echo ""
echo "To stop services:"
echo " $COMPOSE_CMD down"
echo ""
echo "To view logs:"
echo " $COMPOSE_CMD logs -f"
echo ""
tests/e2e/hanzo-net-orchestration/test_local_ai_orchestration.py
-598
View File
@@ -1,598 +0,0 @@
#!/usr/bin/env python3
"""
End-to-End Test: Hanzo Net Local AI Orchestration
This test demonstrates:
1. Starting hanzo net with local AI models
2. Loading Qwen3 (or other local models) as orchestrator
3. Using local AI to orchestrate a subnet of API models (Claude, Codex, Gemini)
4. Cost-optimized routing between local and API models
5. Full MCP tool integration across all agents
"""
import os
import sys
import json
import time
import socket
import asyncio
import logging
import subprocess
from typing import Any, Dict, List, Optional
from pathlib import Path
# Add parent directories to path
sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
from hanzo_network import (
ModelConfig,
NetworkState,
ModelProvider,
create_agent,
create_network,
create_local_agent,
create_routing_agent,
create_distributed_network,
)
from hanzo_network.local_network import check_local_llm_status
# Configure logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)
class HanzoNetE2ETest:
"""End-to-end test for Hanzo Net orchestration."""
def __init__(self):
self.hanzo_net_process = None
self.hanzo_dev_process = None
self.test_results = []
self.models_to_test = [
"qwen3", # Qwen 3
"llama-3.2-3b", # Llama 3.2 3B
"deepseek-v3", # DeepSeek V3
"mistral-7b", # Mistral 7B
]
self.api_models = [
"claude-3-5-sonnet-20241022",
"gpt-4-turbo-preview",
"gemini-pro",
]
async def setup(self):
"""Set up test environment."""
logger.info("Setting up E2E test environment...")
# Check if hanzo net is installed
result = subprocess.run(["which", "hanzo"], capture_output=True, text=True)
if result.returncode != 0:
raise RuntimeError("hanzo CLI not found. Please install: pip install -e pkg/hanzo/")
# Check for required environment variables
self.check_api_keys()
# Create test workspace
self.workspace = Path.home() / ".hanzo" / "e2e-test"
self.workspace.mkdir(parents=True, exist_ok=True)
logger.info(f"Test workspace: {self.workspace}")
def check_api_keys(self):
"""Check for required API keys."""
required_keys = {
"OPENAI_API_KEY": "OpenAI (GPT-4/Codex)",
"ANTHROPIC_API_KEY": "Anthropic (Claude)",
"GOOGLE_API_KEY": "Google (Gemini)",
}
missing_keys = []
for key, service in required_keys.items():
if not os.getenv(key):
missing_keys.append(f"{key} ({service})")
if missing_keys:
logger.warning(f"Missing API keys: {', '.join(missing_keys)}")
logger.warning("Some API models will not be available")
async def start_hanzo_net(self, model: str = "qwen3", port: int = 52415) -> bool:
"""Start hanzo net with specified model."""
logger.info(f"Starting hanzo net with model: {model} on port {port}")
# Check if port is already in use
if self.is_port_open("localhost", port):
logger.warning(f"Port {port} already in use, attempting to use existing instance")
return True
try:
cmd = [
"hanzo",
"net",
"--name",
f"e2e-test-{model}",
"--port",
str(port),
"--models",
model,
"--network",
"local",
"--max-jobs",
"10",
]
logger.info(f"Command: {' '.join(cmd)}")
self.hanzo_net_process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
# Wait for hanzo net to start
for i in range(30): # 30 seconds timeout
await asyncio.sleep(1)
if self.is_port_open("localhost", port):
logger.info(f"✓ hanzo net started successfully on port {port}")
return True
# Check if process has died
if self.hanzo_net_process.poll() is not None:
stdout, stderr = self.hanzo_net_process.communicate()
logger.error(f"hanzo net failed to start:\nSTDOUT: {stdout}\nSTDERR: {stderr}")
return False
logger.error("Timeout waiting for hanzo net to start")
return False
except Exception as e:
logger.error(f"Failed to start hanzo net: {e}")
return False
def is_port_open(self, host: str, port: int) -> bool:
"""Check if a port is open."""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((host, port))
sock.close()
return result == 0
async def create_local_orchestrator(self, model: str, port: int = 52415):
"""Create a local AI orchestrator."""
logger.info(f"Creating local orchestrator with {model}")
orchestrator = create_local_agent(
name=f"{model}_orchestrator",
description=f"Local {model} orchestrator for E2E test",
system="""You are a local AI orchestrator managing a network of specialized agents.
Your role:
1. Coordinate between local and API-based agents
2. Route tasks based on complexity and cost
3. Ensure quality through System 2 thinking
4. Optimize for cost-effectiveness
Available agents:
- Local workers: Fast, free, good for simple tasks
- API workers: Powerful but expensive, for complex tasks
- Critics: Review and improve output quality
Always prefer local models when possible to reduce costs.""",
local_model=model,
base_url=f"http://localhost:{port}",
tools=[],
)
return orchestrator
async def create_agent_network(self, orchestrator_model: str = "qwen3"):
"""Create a full agent network with local orchestrator and mixed workers."""
logger.info("Creating agent network...")
agents = []
# 1. Create local orchestrator
orchestrator = await self.create_local_orchestrator(orchestrator_model)
agents.append(orchestrator)
# 2. Create local worker agents
for i in range(2):
worker = create_local_agent(
name=f"local_worker_{i}",
description=f"Local worker {i} for simple tasks",
system="You are a local worker handling simple code tasks efficiently.",
local_model=orchestrator_model,
base_url="http://localhost:52415",
)
agents.append(worker)
logger.info(f" Created local worker {i}")
# 3. Create API-based worker agents (if keys available)
if os.getenv("ANTHROPIC_API_KEY"):
claude_worker = create_agent(
name="claude_worker",
description="Claude worker for complex implementation",
model=ModelConfig(
provider=ModelProvider.ANTHROPIC,
model="claude-3-5-sonnet-20241022",
api_key=os.getenv("ANTHROPIC_API_KEY"),
),
system="You are Claude, specialized in complex code implementation.",
)
agents.append(claude_worker)
logger.info(" Created Claude worker")
if os.getenv("OPENAI_API_KEY"):
gpt_worker = create_agent(
name="gpt4_worker",
description="GPT-4 worker for analysis and design",
model=ModelConfig(
provider=ModelProvider.OPENAI,
model="gpt-4-turbo-preview",
api_key=os.getenv("OPENAI_API_KEY"),
),
system="You are GPT-4, specialized in code analysis and system design.",
)
agents.append(gpt_worker)
logger.info(" Created GPT-4 worker")
# Also create a Codex-style worker
codex_worker = create_agent(
name="codex_worker",
description="Code completion specialist",
model=ModelConfig(
provider=ModelProvider.OPENAI,
model="gpt-4-turbo-preview", # Using GPT-4 as Codex replacement
api_key=os.getenv("OPENAI_API_KEY"),
temperature=0.2, # Lower temperature for code
),
system="You are a code completion specialist. Generate precise, efficient code.",
)
agents.append(codex_worker)
logger.info(" Created Codex-style worker")
if os.getenv("GOOGLE_API_KEY"):
gemini_worker = create_agent(
name="gemini_worker",
description="Gemini worker for multimodal tasks",
model=ModelConfig(
provider=ModelProvider.GOOGLE,
model="gemini-pro",
api_key=os.getenv("GOOGLE_API_KEY"),
),
system="You are Gemini, capable of handling diverse tasks including code and analysis.",
)
agents.append(gemini_worker)
logger.info(" Created Gemini worker")
# 4. Create critic agents for quality assurance
critic = create_local_agent(
name="local_critic",
description="Local critic for code review",
system="""You are a code quality critic.
Review code for:
- Correctness and bugs
- Performance issues
- Security vulnerabilities
- Best practices
Provide specific, actionable feedback.""",
local_model=orchestrator_model,
base_url="http://localhost:52415",
)
agents.append(critic)
logger.info(" Created local critic")
# 5. Create intelligent router
router = create_routing_agent(
agent=orchestrator,
system="""Route tasks to the most appropriate agent:
Simple tasks (listing, formatting, validation) → local_worker_*
Complex implementation → claude_worker or gpt4_worker
Code completion → codex_worker
Multimodal or diverse tasks → gemini_worker
Code review → local_critic
Optimize for cost by preferring local models when possible.""",
)
# 6. Create the network
network = create_network(agents=agents, router=router, default_agent=orchestrator.name)
logger.info(f"✓ Created agent network with {len(agents)} agents")
return network
async def test_task_routing(self, network):
"""Test that tasks are routed correctly between local and API models."""
logger.info("\n=== Testing Task Routing ===")
test_cases = [
{
"task": "List all Python files in the current directory",
"expected_agent": "local_worker",
"reason": "Simple file listing task",
},
{
"task": "Format this JSON: {'key':'value','nested':{'a':1}}",
"expected_agent": "local_worker",
"reason": "Simple formatting task",
},
{
"task": "Implement a binary search tree with insert, delete, and search operations",
"expected_agent": "claude_worker|gpt4_worker",
"reason": "Complex implementation task",
},
{
"task": "Complete this function: def fibonacci(n): # Calculate nth Fibonacci number",
"expected_agent": "codex_worker|gpt4_worker",
"reason": "Code completion task",
},
{
"task": "Review this code for security issues: eval(user_input)",
"expected_agent": "local_critic",
"reason": "Code review task",
},
]
results = []
for test in test_cases:
logger.info(f"\nTest: {test['task'][:50]}...")
try:
# Create state and run network
state = NetworkState()
result = await network.run(prompt=test["task"], state=state)
# Check which agent handled it
last_message = state.messages[-1] if state.messages else None
agent_used = last_message.get("agent", "unknown") if last_message else "unknown"
# Validate routing
expected_agents = test["expected_agent"].split("|")
success = any(expected in agent_used for expected in expected_agents)
results.append(
{
"task": test["task"][:50],
"expected": test["expected_agent"],
"actual": agent_used,
"success": success,
"reason": test["reason"],
}
)
logger.info(f" Agent used: {agent_used}")
logger.info(f" Success: {'✓' if success else '✗'}")
except Exception as e:
logger.error(f" Error: {e}")
results.append({"task": test["task"][:50], "error": str(e), "success": False})
# Print summary
logger.info("\n=== Routing Test Summary ===")
successful = sum(1 for r in results if r.get("success"))
logger.info(f"Passed: {successful}/{len(results)}")
for result in results:
status = "✓" if result.get("success") else "✗"
logger.info(f" {status} {result.get('task', 'Unknown')}")
if not result.get("success"):
logger.info(f" Expected: {result.get('expected', 'N/A')}")
logger.info(f" Actual: {result.get('actual', result.get('error', 'N/A'))}")
return results
async def test_cost_optimization(self, network):
"""Test that the system optimizes for cost by using local models when possible."""
logger.info("\n=== Testing Cost Optimization ===")
# Track which models handle which tasks
task_distribution = {"local": 0, "api": 0}
# Run a series of mixed tasks
tasks = [
"Check if file exists: config.json",
"Validate this email: [email protected]",
"Count lines in a file",
"Convert string to uppercase",
"Parse a simple CSV line",
# These should go to API models
"Design a microservices architecture for an e-commerce platform",
"Debug this complex concurrency issue in a distributed system",
"Optimize this machine learning pipeline for better performance",
]
for task in tasks:
try:
state = NetworkState()
result = await network.run(prompt=task, state=state)
# Check which type of agent handled it
last_message = state.messages[-1] if state.messages else None
agent_used = last_message.get("agent", "") if last_message else ""
if "local" in agent_used.lower():
task_distribution["local"] += 1
else:
task_distribution["api"] += 1
except Exception as e:
logger.error(f"Error processing task: {e}")
# Calculate cost savings
local_ratio = task_distribution["local"] / len(tasks) if tasks else 0
cost_savings = local_ratio * 100
logger.info(f"\nTask Distribution:")
logger.info(f" Local models: {task_distribution['local']}/{len(tasks)}")
logger.info(f" API models: {task_distribution['api']}/{len(tasks)}")
logger.info(f" Cost savings: ~{cost_savings:.1f}%")
return {
"distribution": task_distribution,
"cost_savings_percent": cost_savings,
"success": cost_savings > 50, # Expect >50% to use local models
}
async def test_hanzo_dev_integration(self, model: str = "qwen3"):
"""Test full hanzo dev integration with local orchestrator."""
logger.info("\n=== Testing Hanzo Dev Integration ===")
try:
# Start hanzo dev with local orchestrator
cmd = [
"hanzo",
"dev",
"--orchestrator",
f"local:{model}",
"--instances",
"3",
"--use-hanzo-net",
"--workspace",
str(self.workspace),
"--no-repl", # Non-interactive mode
"--no-monitor",
]
logger.info(f"Starting hanzo dev: {' '.join(cmd)}")
# Run hanzo dev for a short time to test initialization
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
# Give it time to initialize
await asyncio.sleep(10)
# Check if it's still running
if process.poll() is None:
logger.info("✓ hanzo dev started successfully")
# Terminate gracefully
process.terminate()
await asyncio.sleep(2)
if process.poll() is None:
process.kill()
return True
else:
stdout, stderr = process.communicate()
logger.error(f"hanzo dev failed:\nSTDOUT: {stdout}\nSTDERR: {stderr}")
return False
except Exception as e:
logger.error(f"Failed to test hanzo dev: {e}")
return False
async def run_full_test(self):
"""Run the complete E2E test suite."""
logger.info("\n" + "=" * 60)
logger.info("HANZO NET E2E TEST - LOCAL AI ORCHESTRATION")
logger.info("=" * 60)
all_results = {}
try:
# Setup
await self.setup()
# Test with different local models
for model in self.models_to_test:
logger.info(f"\n{'=' * 60}")
logger.info(f"Testing with model: {model}")
logger.info(f"{'=' * 60}")
model_results = {}
# Start hanzo net with the model
if await self.start_hanzo_net(model):
# Create agent network
network = await self.create_agent_network(model)
# Run tests
model_results["routing"] = await self.test_task_routing(network)
model_results["cost_optimization"] = await self.test_cost_optimization(network)
model_results["hanzo_dev"] = await self.test_hanzo_dev_integration(model)
# Stop hanzo net
if self.hanzo_net_process:
self.hanzo_net_process.terminate()
await asyncio.sleep(2)
self.hanzo_net_process = None
else:
logger.warning(f"Skipping tests for {model} - failed to start hanzo net")
model_results["error"] = "Failed to start hanzo net"
all_results[model] = model_results
# Brief pause between models
await asyncio.sleep(5)
# Print final summary
self.print_summary(all_results)
except Exception as e:
logger.error(f"Test failed: {e}")
raise
finally:
# Cleanup
await self.cleanup()
def print_summary(self, results: Dict):
"""Print test summary."""
logger.info("\n" + "=" * 60)
logger.info("TEST SUMMARY")
logger.info("=" * 60)
for model, model_results in results.items():
logger.info(f"\n{model}:")
if "error" in model_results:
logger.info(f" ✗ {model_results['error']}")
continue
# Routing tests
if "routing" in model_results:
routing = model_results["routing"]
passed = sum(1 for r in routing if r.get("success", False))
logger.info(f" Routing: {passed}/{len(routing)} passed")
# Cost optimization
if "cost_optimization" in model_results:
cost = model_results["cost_optimization"]
if cost.get("success"):
logger.info(f" Cost Optimization: ✓ ({cost['cost_savings_percent']:.1f}% savings)")
else:
logger.info(f" Cost Optimization: ✗")
# Hanzo dev integration
if "hanzo_dev" in model_results:
if model_results["hanzo_dev"]:
logger.info(f" Hanzo Dev Integration: ✓")
else:
logger.info(f" Hanzo Dev Integration: ✗")
async def cleanup(self):
"""Clean up test resources."""
logger.info("\nCleaning up...")
# Stop hanzo net
if self.hanzo_net_process:
self.hanzo_net_process.terminate()
await asyncio.sleep(2)
if self.hanzo_net_process.poll() is None:
self.hanzo_net_process.kill()
# Stop hanzo dev
if self.hanzo_dev_process:
self.hanzo_dev_process.terminate()
await asyncio.sleep(2)
if self.hanzo_dev_process.poll() is None:
self.hanzo_dev_process.kill()
logger.info("Cleanup complete")
async def main():
"""Main entry point."""
test = HanzoNetE2ETest()
await test.run_full_test()
if __name__ == "__main__":
asyncio.run(main())
tests/e2e/hanzo-net-orchestration/test_local_ai_simple.py
-265
View File
@@ -1,265 +0,0 @@
#!/usr/bin/env python3
"""
Simplified E2E Test for Hanzo Net + Hanzo Dev Integration
This test demonstrates the core functionality without requiring hanzo-network package.
"""
import os
import sys
import json
import time
import socket
import asyncio
import logging
import subprocess
from typing import Dict, List, Optional
from pathlib import Path
# Configure logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)
class SimpleHanzoNetTest:
"""Simplified E2E test for hanzo net orchestration."""
def __init__(self):
self.hanzo_net_process = None
self.hanzo_dev_process = None
self.workspace = Path.home() / ".hanzo" / "e2e-test"
self.workspace.mkdir(parents=True, exist_ok=True)
def is_port_open(self, host: str, port: int) -> bool:
"""Check if a port is open."""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((host, port))
sock.close()
return result == 0
async def test_hanzo_net_startup(self, model: str = "llama-3.2-3b") -> bool:
"""Test that hanzo net can start with a local model."""
logger.info(f"\n=== Testing Hanzo Net Startup with {model} ===")
port = 52415
# Check if already running
if self.is_port_open("localhost", port):
logger.info(f"✓ Port {port} already in use (hanzo net may be running)")
return True
try:
# Start hanzo net
cmd = [
"hanzo",
"net",
"--name",
"e2e-test",
"--port",
str(port),
"--models",
model,
"--network",
"local",
]
logger.info(f"Starting: {' '.join(cmd)}")
self.hanzo_net_process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
# Wait for startup
for i in range(30):
await asyncio.sleep(1)
if self.is_port_open("localhost", port):
logger.info(f"✓ hanzo net started on port {port}")
return True
# Check if process died
if self.hanzo_net_process.poll() is not None:
stdout, stderr = self.hanzo_net_process.communicate()
logger.error(f"hanzo net failed to start")
logger.error(f"STDERR: {stderr}")
return False
logger.error("Timeout waiting for hanzo net")
return False
except Exception as e:
logger.error(f"Error starting hanzo net: {e}")
return False
async def test_hanzo_dev_with_local(self, model: str = "llama-3.2-3b") -> bool:
"""Test hanzo dev with local orchestrator."""
logger.info(f"\n=== Testing Hanzo Dev with Local Orchestrator ===")
try:
# Start hanzo dev with local orchestrator
cmd = [
"hanzo",
"dev",
"--orchestrator",
f"local:{model}",
"--instances",
"2",
"--use-hanzo-net",
"--workspace",
str(self.workspace),
]
logger.info(f"Starting: {' '.join(cmd)}")
# Start process and capture output
process = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
bufsize=1,
)
# Read output for a few seconds
start_time = time.time()
output_lines = []
success_indicators = [
"Agent network initialized",
"Created local",
"orchestrator",
"hanzo/net started",
]
while time.time() - start_time < 15: # 15 second timeout
line = process.stdout.readline()
if line:
output_lines.append(line.strip())
logger.info(f" {line.strip()}")
# Check for success indicators
for indicator in success_indicators:
if indicator.lower() in line.lower():
logger.info(f"✓ Found: {indicator}")
# Check if process died
if process.poll() is not None:
break
await asyncio.sleep(0.1)
# Terminate the process
process.terminate()
await asyncio.sleep(2)
if process.poll() is None:
process.kill()
# Check if we saw success indicators
full_output = "\n".join(output_lines)
if any(
indicator in full_output.lower() for indicator in ["network initialized", "orchestrator", "started"]
):
logger.info("✓ hanzo dev initialized successfully")
return True
else:
logger.warning("Could not confirm successful initialization")
return False
except Exception as e:
logger.error(f"Error testing hanzo dev: {e}")
return False
async def test_cost_optimization_config(self) -> bool:
"""Test that cost optimization is configured correctly."""
logger.info("\n=== Testing Cost Optimization Configuration ===")
# Check if the dev.py file has cost optimization logic
dev_file = Path(__file__).parent.parent.parent.parent / "pkg" / "hanzo" / "src" / "hanzo" / "dev.py"
if dev_file.exists():
content = dev_file.read_text()
checks = {
"CostOptimizedRouter": "Cost-optimized router class",
"local_workers": "Local worker configuration",
"simple_keywords": "Simple task detection",
"complex_keywords": "Complex task detection",
"local models preferred": "Local model preference",
}
results = []
for key, description in checks.items():
if key.lower() in content.lower():
logger.info(f" ✓ {description} found")
results.append(True)
else:
logger.warning(f" ✗ {description} not found")
results.append(False)
success = all(results)
if success:
logger.info("✓ Cost optimization properly configured")
else:
logger.warning("⚠ Some cost optimization features missing")
return success
else:
logger.error(f"dev.py not found at {dev_file}")
return False
async def run_all_tests(self):
"""Run all tests."""
logger.info("\n" + "=" * 60)
logger.info("HANZO NET SIMPLE E2E TEST")
logger.info("=" * 60)
results = {}
try:
# Test 1: Hanzo net startup
results["hanzo_net"] = await self.test_hanzo_net_startup()
# Test 2: Hanzo dev with local orchestrator
results["hanzo_dev"] = await self.test_hanzo_dev_with_local()
# Test 3: Cost optimization configuration
results["cost_optimization"] = await self.test_cost_optimization_config()
# Summary
logger.info("\n" + "=" * 60)
logger.info("TEST SUMMARY")
logger.info("=" * 60)
for test_name, success in results.items():
status = "✓ PASSED" if success else "✗ FAILED"
logger.info(f"{test_name}: {status}")
all_passed = all(results.values())
if all_passed:
logger.info("\n✓ All tests passed!")
else:
logger.info("\n✗ Some tests failed")
return all_passed
finally:
# Cleanup
if self.hanzo_net_process:
self.hanzo_net_process.terminate()
await asyncio.sleep(1)
if self.hanzo_net_process.poll() is None:
self.hanzo_net_process.kill()
if self.hanzo_dev_process:
self.hanzo_dev_process.terminate()
await asyncio.sleep(1)
if self.hanzo_dev_process.poll() is None:
self.hanzo_dev_process.kill()
async def main():
"""Main entry point."""
test = SimpleHanzoNetTest()
success = await test.run_all_tests()
sys.exit(0 if success else 1)
if __name__ == "__main__":
asyncio.run(main())
tests/mock_fixtures.py
-412
View File
@@ -1,412 +0,0 @@
# Mock fixtures for integration tests
import json
import respx
import pytest
from httpx import Response
@pytest.fixture
def mock_api(request):
"""Mock API responses for integration tests"""
# Don't set up mocks if the test is using respx_mock directly
if "respx_mock" in request.fixturenames:
yield None
return
with respx.mock(base_url="http://127.0.0.1:4010", assert_all_called=False) as respx_mock:
# Audio endpoints
respx_mock.post("/audio/speech").mock(return_value=Response(200, json={}))
respx_mock.post("/audio/transcriptions").mock(return_value=Response(200, json={}))
# Batch endpoints
respx_mock.post("/batch/cancel").mock(return_value=Response(200, json={}))
respx_mock.post("/batches").mock(return_value=Response(200, json={"id": "batch-123"}))
respx_mock.get("/batches").mock(return_value=Response(200, json={"data": []}))
respx_mock.route(method="GET", path__regex=r"/batches/.*").mock(
return_value=Response(200, json={"id": "batch-123"})
)
respx_mock.route(method="POST", path__regex=r"/batches/.*/cancel").mock(return_value=Response(200, json={}))
# Cache endpoints
respx_mock.get("/cache/ping").mock(
return_value=Response(
200,
json={
"status": "healthy",
"cache_type": "redis",
"ping_response": True,
"set_cache_response": None,
"llm_cache_params": None,
"health_check_cache_params": None,
},
)
)
respx_mock.post("/cache/delete").mock(return_value=Response(200, json={}))
respx_mock.post("/cache/flushall").mock(return_value=Response(200, json={}))
respx_mock.get("/cache/redis/ping").mock(return_value=Response(200, json={"status": "ok"}))
respx_mock.delete("/cache").mock(return_value=Response(200, json={}))
respx_mock.get("/cache/flush").mock(return_value=Response(200, json={}))
# Chat completions
respx_mock.post("/chat/completions").mock(
return_value=Response(
200,
json={
"id": "chatcmpl-123",
"object": "chat.completion",
"created": 1677652288,
"model": "gpt-3.5-turbo",
"choices": [
{
"index": 0,
"message": {"role": "assistant", "content": "Hello!"},
"finish_reason": "stop",
}
],
},
)
)
# Config endpoints
respx_mock.post("/config/pass_through_endpoints").mock(return_value=Response(200, json={}))
respx_mock.post("/config/pass_through_endpoint").mock(return_value=Response(200, json={}))
respx_mock.route(method="PUT", path__regex=r"/config/pass_through_endpoints/.*").mock(
return_value=Response(200, json={})
)
respx_mock.get("/config/pass_through_endpoints").mock(return_value=Response(200, json={"data": []}))
respx_mock.get("/config/pass_through_endpoint").mock(return_value=Response(200, json={"endpoints": []}))
respx_mock.delete("/config/pass_through_endpoint").mock(return_value=Response(200, json={"endpoints": []}))
respx_mock.route(method="DELETE", path__regex=r"/config/pass_through_endpoints/.*").mock(
return_value=Response(200, json={})
)
# Engine endpoints
respx_mock.route(method="POST", path__regex=r"/engines/.*/chat/completions").mock(
return_value=Response(200, json={})
)
# Files
respx_mock.route(method="GET", path__regex=r"/files/.*/content").mock(
return_value=Response(200, json="file content")
)
respx_mock.route(method="GET", path__regex=r"/.*/v1/files/.*/content").mock(
return_value=Response(200, json="file content")
)
respx_mock.post("/files").mock(return_value=Response(200, json={"id": "file-123"}))
respx_mock.get("/files").mock(return_value=Response(200, json={"data": []}))
respx_mock.route(method="DELETE", path__regex=r"/files/.*").mock(return_value=Response(200, json={}))
# Fine-tuning
respx_mock.post("/fine_tuning/jobs").mock(return_value=Response(200, json={"id": "ft-123"}))
respx_mock.get("/fine_tuning/jobs").mock(return_value=Response(200, json={"data": []}))
respx_mock.route(method="GET", path__regex=r"/fine_tuning/jobs/[^/]+$").mock(
return_value=Response(200, json={"id": "ft-123"})
)
respx_mock.route(method="POST", path__regex=r"/fine_tuning/jobs/.*/cancel").mock(
return_value=Response(200, json={})
)
# Global spend
respx_mock.get("/global/spend/tags").mock(return_value=Response(200, json=[]))
respx_mock.post("/global/spend/reset").mock(return_value=Response(200, json={}))
respx_mock.get("/global/spend/report").mock(return_value=Response(200, json=[]))
# Guardrails
respx_mock.get("/guardrails/list").mock(return_value=Response(200, json={"guardrails": []}))
# Images
respx_mock.post("/images/generations").mock(return_value=Response(200, json={"data": []}))
# Models
respx_mock.get("/model/info").mock(return_value=Response(200, json={"data": []}))
respx_mock.put("/models/update").mock(return_value=Response(200, json={}))
respx_mock.route(method="PATCH", path__regex=r"/models/.*").mock(return_value=Response(200, json={}))
respx_mock.post("/models").mock(return_value=Response(200, json={}))
respx_mock.get("/models").mock(return_value=Response(200, json={"data": []}))
respx_mock.route(method="DELETE", path__regex=r"/models/.*").mock(return_value=Response(200, json={}))
# OpenAI deployments
respx_mock.route(method="POST", path__regex=r"/openai/deployments/.*/chat/completions").mock(
return_value=Response(200, json={})
)
respx_mock.route(method="POST", path__regex=r"/openai/deployments/.*/completions").mock(
return_value=Response(200, json={})
)
respx_mock.route(method="POST", path__regex=r"/openai/deployments/.*/embeddings").mock(
return_value=Response(200, json={})
)
# Organization
org_response = {
"budget_id": "budget-123",
"created_at": "2024-01-01T00:00:00Z",
"created_by": "user-123",
"models": ["gpt-3.5-turbo"],
"organization_id": "org-123",
"updated_at": "2024-01-01T00:00:00Z",
"updated_by": "user-123",
}
respx_mock.get("/organization/info").mock(
return_value=Response(
200,
json={
"budget_id": "budget-123",
"created_at": "2024-01-01T00:00:00Z",
"created_by": "user-123",
"models": ["gpt-3.5-turbo"],
"updated_at": "2024-01-01T00:00:00Z",
"updated_by": "user-123",
},
)
)
respx_mock.get("/organization/info/deprecated").mock(return_value=Response(200, json={}))
respx_mock.post("/organization/new").mock(return_value=Response(200, json=org_response))
respx_mock.post("/organization").mock(return_value=Response(200, json={}))
respx_mock.get("/organization/list").mock(return_value=Response(200, json=[]))
respx_mock.get("/organization").mock(return_value=Response(200, json=[]))
org_update_response = {
"budget_id": "budget-123",
"created_at": "2024-01-01T00:00:00Z",
"created_by": "user-123",
"models": ["gpt-3.5-turbo"],
"updated_at": "2024-01-01T00:00:00Z",
"updated_by": "user-123",
"organization_id": "org-123",
"members": [],
"teams": [],
}
respx_mock.patch("/organization/update").mock(return_value=Response(200, json=org_update_response))
respx_mock.put("/organization/update").mock(return_value=Response(200, json=org_update_response))
respx_mock.put("/organization").mock(return_value=Response(200, json={}))
respx_mock.delete("/organization/delete").mock(return_value=Response(200, json=[org_response]))
respx_mock.delete("/organization").mock(return_value=Response(200, json={}))
org_member_response = {
"organization_id": "org-123",
"updated_organization_memberships": [],
"updated_users": [],
}
respx_mock.post("/organization/member_add").mock(return_value=Response(200, json=org_member_response))
respx_mock.post("/organization/members").mock(return_value=Response(200, json={}))
respx_mock.delete("/organization/member_delete").mock(return_value=Response(200, json=org_response))
respx_mock.delete("/organization/members").mock(return_value=Response(200, json={}))
org_update_member_response = {
"created_at": "2024-01-01T00:00:00Z",
"organization_id": "org-123",
"updated_at": "2024-01-01T00:00:00Z",
"user_id": "user-123",
}
respx_mock.patch("/organization/member_update").mock(
return_value=Response(200, json=org_update_member_response)
)
respx_mock.put("/organization/member_update").mock(return_value=Response(200, json=org_update_member_response))
respx_mock.put("/organization/members").mock(return_value=Response(200, json={}))
# Responses
respx_mock.route(method="GET", path__regex=r"/responses/.*/input_items").mock(
return_value=Response(200, json={"data": []})
)
# Team
team_response = {
"team_id": "team-123",
"models": [],
"members": [],
"admins": [],
}
respx_mock.route(method="GET", path__regex=r"/team/.*/callback").mock(return_value=Response(200, json={}))
respx_mock.route(method="POST", path__regex=r"/team/.*/callback").mock(return_value=Response(200, json={}))
respx_mock.post("/team/model").mock(return_value=Response(200, json={}))
respx_mock.delete("/team/model").mock(return_value=Response(200, json={}))
respx_mock.post("/team/new").mock(return_value=Response(200, json=team_response))
respx_mock.post("/team").mock(return_value=Response(200, json={}))
respx_mock.get("/team/list").mock(return_value=Response(200, json=[]))
respx_mock.get("/team").mock(return_value=Response(200, json=[]))
respx_mock.get("/team/info").mock(return_value=Response(200, json=team_response))
respx_mock.patch("/team/update").mock(return_value=Response(200, json=team_response))
respx_mock.put("/team/update").mock(return_value=Response(200, json=team_response))
respx_mock.put("/team").mock(return_value=Response(200, json={}))
respx_mock.delete("/team/delete").mock(return_value=Response(200, json=[team_response]))
respx_mock.delete("/team").mock(return_value=Response(200, json={}))
team_add_member_response = {
"team_id": "team-123",
"updated_team_memberships": [],
"updated_users": [],
}
team_update_member_response = {"team_id": "team-123", "user_id": "user-123"}
respx_mock.post("/team/member_add").mock(return_value=Response(200, json=team_add_member_response))
respx_mock.post("/team/members").mock(return_value=Response(200, json={}))
respx_mock.delete("/team/member_delete").mock(return_value=Response(200, json=team_response))
respx_mock.delete("/team/members").mock(return_value=Response(200, json={}))
respx_mock.post("/team/member_update").mock(return_value=Response(200, json=team_update_member_response))
respx_mock.patch("/team/member_update").mock(return_value=Response(200, json=team_update_member_response))
respx_mock.put("/team/member_update").mock(return_value=Response(200, json=team_update_member_response))
respx_mock.put("/team/members").mock(return_value=Response(200, json={}))
respx_mock.post("/team/block").mock(return_value=Response(200, json=team_response))
respx_mock.post("/team/unblock").mock(return_value=Response(200, json=team_response))
# Other endpoints
respx_mock.get("/active/callbacks").mock(return_value=Response(200, json={"data": []}))
respx_mock.post("/add/allowed_ip").mock(return_value=Response(200, json={}))
respx_mock.post("/delete/allowed_ip").mock(return_value=Response(200, json={}))
# Provider endpoints (anthropic, azure, bedrock, etc.)
for provider in [
"anthropic",
"azure",
"bedrock",
"cohere",
"gemini",
"openai",
"vertex_ai",
"assemblyai",
"eu_assemblyai",
]:
respx_mock.post(f"/{provider}").mock(return_value=Response(200, json={}))
respx_mock.get(f"/{provider}").mock(return_value=Response(200, json={"data": []}))
respx_mock.route(method="GET", path__regex=rf"/{provider}/.*").mock(return_value=Response(200, json={}))
respx_mock.put(f"/{provider}").mock(return_value=Response(200, json={}))
respx_mock.route(method="PUT", path__regex=rf"/{provider}/.*").mock(return_value=Response(200, json={}))
respx_mock.patch(f"/{provider}").mock(return_value=Response(200, json={}))
respx_mock.route(method="PATCH", path__regex=rf"/{provider}/.*").mock(return_value=Response(200, json={}))
respx_mock.delete(f"/{provider}").mock(return_value=Response(200, json={}))
respx_mock.route(method="DELETE", path__regex=rf"/{provider}/.*").mock(return_value=Response(200, json={}))
respx_mock.post(f"/{provider}/modify").mock(return_value=Response(200, json={}))
respx_mock.post(f"/{provider}/call").mock(return_value=Response(200, json={}))
# Assistants
respx_mock.post("/assistants").mock(return_value=Response(200, json={}))
respx_mock.get("/assistants").mock(return_value=Response(200, json={"data": []}))
respx_mock.route(method="DELETE", path__regex=r"/assistants/.*").mock(return_value=Response(200, json={}))
# Budget
respx_mock.post("/budget").mock(return_value=Response(200, json={}))
respx_mock.put("/budget").mock(return_value=Response(200, json={}))
respx_mock.get("/budget").mock(return_value=Response(200, json={"data": []}))
respx_mock.delete("/budget").mock(return_value=Response(200, json={}))
respx_mock.get("/budget/info").mock(return_value=Response(200, json={}))
respx_mock.get("/budget/settings").mock(return_value=Response(200, json={}))
# Completions
respx_mock.post("/completions").mock(return_value=Response(200, json={}))
# Credentials
respx_mock.post("/credentials").mock(return_value=Response(200, json={}))
respx_mock.put("/credentials").mock(return_value=Response(200, json={}))
# Customer
respx_mock.post("/customer").mock(return_value=Response(200, json={}))
respx_mock.get("/customer").mock(return_value=Response(200, json={"data": []}))
respx_mock.get("/customer/list").mock(return_value=Response(200, json=[]))
respx_mock.get("/customer/info").mock(
return_value=Response(200, json={"blocked": False, "user_id": "user-123"})
)
respx_mock.put("/customer").mock(return_value=Response(200, json={}))
respx_mock.delete("/customer").mock(return_value=Response(200, json={}))
respx_mock.post("/customer/block").mock(return_value=Response(200, json={}))
respx_mock.post("/customer/unblock").mock(return_value=Response(200, json={}))
# Embeddings
respx_mock.post("/embeddings").mock(return_value=Response(200, json={"data": []}))
# Guardrails
respx_mock.get("/guardrails").mock(return_value=Response(200, json={"data": []}))
# Health
respx_mock.get("/health").mock(return_value=Response(200, json={"status": "healthy"}))
respx_mock.get("/health/services").mock(return_value=Response(200, json={}))
# Key management
respx_mock.post("/key").mock(return_value=Response(200, json={}))
respx_mock.get("/key").mock(return_value=Response(200, json={"data": []}))
respx_mock.get("/key/info").mock(return_value=Response(200, json={}))
respx_mock.put("/key").mock(return_value=Response(200, json={}))
respx_mock.delete("/key").mock(return_value=Response(200, json={}))
respx_mock.post("/key/generate").mock(return_value=Response(200, json={"key": "sk-123"}))
respx_mock.post("/key/regenerate").mock(return_value=Response(200, json={"key": "sk-456"}))
respx_mock.post("/key/key/regenerate").mock(return_value=Response(200, json={"key": "sk-789"}))
respx_mock.post("/key/block").mock(return_value=Response(200, json={}))
respx_mock.post("/key/unblock").mock(return_value=Response(200, json={}))
respx_mock.get("/key/health").mock(return_value=Response(200, json={"status": "ok"}))
# Langfuse
respx_mock.post("/langfuse").mock(return_value=Response(200, json={}))
# Model group
respx_mock.get("/model_group/info").mock(return_value=Response(200, json={}))
# Moderations
respx_mock.post("/moderations").mock(return_value=Response(200, json={}))
# Provider
respx_mock.get("/provider/budgets").mock(return_value=Response(200, json={"data": []}))
# Rerank
respx_mock.post("/rerank").mock(return_value=Response(200, json={}))
# Routes
respx_mock.get("/routes").mock(return_value=Response(200, json={"data": []}))
# Settings
respx_mock.get("/settings").mock(return_value=Response(200, json={}))
# Spend
respx_mock.get("/spend/calculate").mock(return_value=Response(200, json={}))
respx_mock.get("/spend/logs").mock(return_value=Response(200, json=[]))
respx_mock.get("/spend/tags").mock(return_value=Response(200, json=[]))
# Test
respx_mock.get("/test").mock(return_value=Response(200, json={}))
# Root endpoint for client tests
respx_mock.get("/").mock(return_value=Response(200, json={}))
# Threads
respx_mock.post("/threads").mock(return_value=Response(200, json={}))
respx_mock.get("/threads").mock(return_value=Response(200, json={"data": []}))
respx_mock.route(method="GET", path__regex=r"/threads/[^/]+$").mock(return_value=Response(200, json={}))
respx_mock.route(method="PUT", path__regex=r"/threads/.*").mock(return_value=Response(200, json={}))
respx_mock.route(method="DELETE", path__regex=r"/threads/.*").mock(return_value=Response(200, json={}))
respx_mock.route(method="POST", path__regex=r"/threads/.*/messages").mock(return_value=Response(200, json={}))
respx_mock.route(method="GET", path__regex=r"/threads/.*/messages").mock(
return_value=Response(200, json={"data": []})
)
respx_mock.route(method="POST", path__regex=r"/threads/.*/runs").mock(return_value=Response(200, json={}))
respx_mock.route(method="GET", path__regex=r"/threads/.*/runs").mock(
return_value=Response(200, json={"data": []})
)
# User
user_response = {"key": "sk-user-123", "user_id": "user-123"}
respx_mock.post("/user/new").mock(return_value=Response(200, json=user_response))
respx_mock.post("/user").mock(return_value=Response(200, json={}))
respx_mock.get("/user/list").mock(return_value=Response(200, json=[]))
respx_mock.get("/user").mock(return_value=Response(200, json=[]))
respx_mock.get("/user/info").mock(return_value=Response(200, json=user_response))
respx_mock.put("/user/update").mock(return_value=Response(200, json=user_response))
respx_mock.put("/user").mock(return_value=Response(200, json={}))
respx_mock.delete("/user/delete").mock(return_value=Response(200, json=user_response))
respx_mock.delete("/user").mock(return_value=Response(200, json={}))
# Utils
respx_mock.get("/utils/supported_openai_params").mock(return_value=Response(200, json={}))
respx_mock.post("/utils/token_counter").mock(
return_value=Response(
200,
json={
"model_used": "gpt-3.5-turbo",
"request_model": "gpt-3.5-turbo",
"tokenizer_type": "cl100k_base",
"total_tokens": 10,
},
)
)
respx_mock.post("/utils/transform_request").mock(return_value=Response(200, json={}))
# Home/client
respx_mock.get("/").mock(return_value=Response(200, json={"message": "Welcome"}))
# Catch-all for any unmocked endpoints
respx_mock.route().mock(return_value=Response(200, json={}))
yield respx_mock
tests/sample_file.txt
-1
View File
@@ -1 +0,0 @@
Hello, world!
tests/start_mock_server.py
-116
View File
@@ -1,116 +0,0 @@
#!/usr/bin/env python3
"""Comprehensive mock server for all test endpoints."""
import sys
import json
from http.server import HTTPServer, BaseHTTPRequestHandler
class MockHandler(BaseHTTPRequestHandler):
def do_GET(self):
"""Handle GET requests."""
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.end_headers()
# Default response
response = {}
# Handle specific endpoints
if "/files/" in self.path and "/content" in self.path:
response = "file content"
elif self.path == "/guardrails/list":
response = {"guardrails": []}
elif self.path == "/global/spend/tags":
response = []
elif self.path == "/global/spend/report":
response = []
elif self.path == "/organization/info":
response = {
"budget_id": "budget-123",
"created_at": "2024-01-01T00:00:00Z",
"created_by": "user-123",
"models": ["gpt-3.5-turbo"],
"updated_at": "2024-01-01T00:00:00Z",
"updated_by": "user-123",
}
elif self.path == "/config/pass_through_endpoint":
response = {"endpoints": []}
elif self.path == "/":
response = {}
else:
response = {"data": []}
self.wfile.write(json.dumps(response).encode())
def do_POST(self):
"""Handle POST requests."""
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.end_headers()
# Default response
response = {}
# Handle specific endpoints
if self.path == "/utils/token_counter":
response = {
"model_used": "gpt-3.5-turbo",
"request_model": "gpt-3.5-turbo",
"tokenizer_type": "cl100k_base",
"total_tokens": 10,
}
elif self.path == "/chat/completions":
response = {
"id": "chatcmpl-123",
"object": "chat.completion",
"created": 1677652288,
"model": "gpt-3.5-turbo",
"choices": [
{
"index": 0,
"message": {"role": "assistant", "content": "Hello!"},
"finish_reason": "stop",
}
],
}
self.wfile.write(json.dumps(response).encode())
def do_PUT(self):
"""Handle PUT requests."""
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.end_headers()
self.wfile.write(b"{}")
def do_DELETE(self):
"""Handle DELETE requests."""
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.end_headers()
# Handle specific endpoints
if self.path == "/config/pass_through_endpoint":
response = {"endpoints": []}
else:
response = {}
self.wfile.write(json.dumps(response).encode())
def log_message(self, format, *args):
pass # Suppress logs
if __name__ == "__main__":
try:
server = HTTPServer(("127.0.0.1", 4010), MockHandler)
print("Mock server started on http://127.0.0.1:4010")
print("Press Ctrl+C to stop")
server.serve_forever()
except KeyboardInterrupt:
print("\nShutting down mock server...")
sys.exit(0)
except Exception as e:
print(f"Error: {e}")
sys.exit(1)
tests/test_api_response.py
-157
View File
@@ -1,157 +0,0 @@
#!/usr/bin/env python3
"""Test actual AI API responses."""
import os
import sys
import asyncio
from pathlib import Path
# Add src to path
sys.path.insert(0, str(Path(__file__).parent / "pkg" / "hanzo" / "src"))
async def test_openai_api():
"""Test OpenAI API response."""
if not os.getenv("OPENAI_API_KEY"):
print("✗ OpenAI API key not set")
return False
try:
from openai import AsyncOpenAI
client = AsyncOpenAI()
response = await client.chat.completions.create(
model="gpt-4",
messages=[
{
"role": "system",
"content": "You are a helpful assistant. Reply with exactly: 'API test successful'",
},
{"role": "user", "content": "Test"},
],
max_tokens=50,
)
if response.choices and "successful" in response.choices[0].message.content:
print(f"✓ OpenAI API works: {response.choices[0].message.content}")
return True
else:
print("✗ OpenAI API response unexpected")
return False
except Exception as e:
print(f"✗ OpenAI API error: {e}")
return False
async def test_anthropic_api():
"""Test Anthropic API response."""
if not os.getenv("ANTHROPIC_API_KEY"):
print("✗ Anthropic API key not set")
return False
try:
from anthropic import AsyncAnthropic
client = AsyncAnthropic()
response = await client.messages.create(
model="claude-3-5-sonnet-20241022",
messages=[{"role": "user", "content": "Reply with exactly: 'API test successful'"}],
max_tokens=50,
)
if response.content and "successful" in response.content[0].text:
print(f"✓ Anthropic API works: {response.content[0].text}")
return True
else:
print("✗ Anthropic API response unexpected")
return False
except Exception as e:
print(f"✗ Anthropic API error: {e}")
return False
async def test_ollama_local():
"""Test Ollama local model."""
try:
import httpx
async with httpx.AsyncClient() as client:
# Check if Ollama is running
response = await client.get("http://localhost:11434/api/tags")
if response.status_code == 200:
data = response.json()
models = data.get("models", [])
if models:
print(f"✓ Ollama running with {len(models)} model(s)")
# Try a simple generation
model_name = models[0]["name"]
gen_response = await client.post(
"http://localhost:11434/api/generate",
json={
"model": model_name,
"prompt": "Reply with: test",
"stream": False,
},
timeout=30.0,
)
if gen_response.status_code == 200:
print(f"✓ Ollama model {model_name} responds")
return True
else:
print("✗ Ollama running but no models installed")
print(" Install with: ollama pull llama3.2")
return False
else:
print("✗ Ollama not responding")
return False
except Exception as e:
print(f"✗ Ollama not available: {e}")
print(" Install with: curl -fsSL https://ollama.com/install.sh | sh")
return False
async def main():
"""Run API tests."""
print("\n" + "=" * 60)
print("TESTING ACTUAL AI API RESPONSES")
print("=" * 60 + "\n")
results = []
# Test OpenAI
print("Testing OpenAI API...")
results.append(await test_openai_api())
print()
# Test Anthropic
print("Testing Anthropic API...")
results.append(await test_anthropic_api())
print()
# Test Ollama
print("Testing Ollama (local)...")
results.append(await test_ollama_local())
print()
# Summary
print("=" * 60)
if any(results):
print("✅ At least one AI API is working!")
print("You can use hanzo dev with the working APIs")
else:
print("⚠️ No AI APIs are currently working")
print("You can still use CLI tools or free APIs")
return any(results)
if __name__ == "__main__":
success = asyncio.run(main())
sys.exit(0 if success else 1)

Some files were not shown because too many files have changed in this diff Show More