spitch 1.39.0__tar.gz → 1.40.0__tar.gz

spitch-1.40.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.40.0"
+}

{spitch-1.39.0 → spitch-1.40.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.40.0 (2025-10-16)
+
+Full Changelog: [v1.39.0...v1.40.0](https://github.com/spi-tch/spitch-python/compare/v1.39.0...v1.40.0)
+
+### Features
+
+* **api:** manual updates ([578dbb8](https://github.com/spi-tch/spitch-python/commit/578dbb81d604d24899f6687fe6dd2a32a923ac15))
+
+
+### Chores
+
+* **internal:** detect missing future annotations with ruff ([36529fc](https://github.com/spi-tch/spitch-python/commit/36529fcafde8b0aa37800296b6b27b4f8fbe7984))
+
 ## 1.39.0 (2025-10-07)
 
 Full Changelog: [v1.38.0...v1.39.0](https://github.com/spi-tch/spitch-python/compare/v1.38.0...v1.39.0)

{spitch-1.39.0 → spitch-1.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: spitch
-Version: 1.39.0
+Version: 1.40.0
 Summary: The official Python library for the spitch API
 Project-URL: Homepage, https://github.com/spi-tch/spitch-python
 Project-URL: Repository, https://github.com/spi-tch/spitch-python

{spitch-1.39.0 → spitch-1.40.0}/api.md

@@ -40,3 +40,16 @@ Methods:
 - <code title="get /v1/files/{file_id}">client.files.<a href="./src/spitch/resources/files.py">get</a>(file_id) -> <a href="./src/spitch/types/file.py">File</a></code>
 - <code title="post /v1/files">client.files.<a href="./src/spitch/resources/files.py">upload</a>(\*\*<a href="src/spitch/types/file_upload_params.py">params</a>) -> <a href="./src/spitch/types/file.py">File</a></code>
 - <code title="get /v1/files:usage">client.files.<a href="./src/spitch/resources/files.py">usage</a>() -> <a href="./src/spitch/types/file_usage.py">FileUsage</a></code>
+
+# Jobs
+
+Types:
+
+```python
+from spitch.types import Job, Jobs
+```
+
+Methods:
+
+- <code title="get /v1/jobs">client.jobs.<a href="./src/spitch/resources/jobs.py">list</a>(\*\*<a href="src/spitch/types/job_list_params.py">params</a>) -> <a href="./src/spitch/types/job.py">SyncFilesCursor[Job]</a></code>
+- <code title="get /v1/jobs/{job_id}">client.jobs.<a href="./src/spitch/resources/jobs.py">get</a>(job_id) -> <a href="./src/spitch/types/job.py">Job</a></code>

{spitch-1.39.0 → spitch-1.40.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spitch"
-version = "1.39.0"
+version = "1.40.0"
 description = "The official Python library for the spitch API"
 dynamic = ["readme"]
 license = "Apache-2.0"
@@ -225,6 +225,8 @@ select = [
   "B",
   # remove unused imports
   "F401",
+  # check for missing future annotations
+  "FA102",
   # bare except statements
   "E722",
   # unused arguments
@@ -247,6 +249,8 @@ unfixable = [
   "T203",
 ]
 
+extend-safe-fixes = ["FA102"]
+
 [tool.ruff.lint.flake8-tidy-imports.banned-api]
 "functools.lru_cache".msg = "This function does not retain type information for the wrapped function's arguments; The `lru_cache` function from `_utils` should be used instead"
 

{spitch-1.39.0 → spitch-1.40.0}/src/spitch/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import text, files, speech
+from .resources import jobs, text, files, speech
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import SpitchError, APIStatusError
 from ._base_client import (
@@ -47,6 +47,7 @@ class Spitch(SyncAPIClient):
     speech: speech.SpeechResource
     text: text.TextResource
     files: files.FilesResource
+    jobs: jobs.JobsResource
     with_raw_response: SpitchWithRawResponse
     with_streaming_response: SpitchWithStreamedResponse
 
@@ -107,6 +108,7 @@ class Spitch(SyncAPIClient):
         self.speech = speech.SpeechResource(self)
         self.text = text.TextResource(self)
         self.files = files.FilesResource(self)
+        self.jobs = jobs.JobsResource(self)
         self.with_raw_response = SpitchWithRawResponse(self)
         self.with_streaming_response = SpitchWithStreamedResponse(self)
 
@@ -219,6 +221,7 @@ class AsyncSpitch(AsyncAPIClient):
     speech: speech.AsyncSpeechResource
     text: text.AsyncTextResource
     files: files.AsyncFilesResource
+    jobs: jobs.AsyncJobsResource
     with_raw_response: AsyncSpitchWithRawResponse
     with_streaming_response: AsyncSpitchWithStreamedResponse
 
@@ -279,6 +282,7 @@ class AsyncSpitch(AsyncAPIClient):
         self.speech = speech.AsyncSpeechResource(self)
         self.text = text.AsyncTextResource(self)
         self.files = files.AsyncFilesResource(self)
+        self.jobs = jobs.AsyncJobsResource(self)
         self.with_raw_response = AsyncSpitchWithRawResponse(self)
         self.with_streaming_response = AsyncSpitchWithStreamedResponse(self)
 
@@ -392,6 +396,7 @@ class SpitchWithRawResponse:
         self.speech = speech.SpeechResourceWithRawResponse(client.speech)
         self.text = text.TextResourceWithRawResponse(client.text)
         self.files = files.FilesResourceWithRawResponse(client.files)
+        self.jobs = jobs.JobsResourceWithRawResponse(client.jobs)
 
 
 class AsyncSpitchWithRawResponse:
@@ -399,6 +404,7 @@ class AsyncSpitchWithRawResponse:
         self.speech = speech.AsyncSpeechResourceWithRawResponse(client.speech)
         self.text = text.AsyncTextResourceWithRawResponse(client.text)
         self.files = files.AsyncFilesResourceWithRawResponse(client.files)
+        self.jobs = jobs.AsyncJobsResourceWithRawResponse(client.jobs)
 
 
 class SpitchWithStreamedResponse:
@@ -406,6 +412,7 @@ class SpitchWithStreamedResponse:
         self.speech = speech.SpeechResourceWithStreamingResponse(client.speech)
         self.text = text.TextResourceWithStreamingResponse(client.text)
         self.files = files.FilesResourceWithStreamingResponse(client.files)
+        self.jobs = jobs.JobsResourceWithStreamingResponse(client.jobs)
 
 
 class AsyncSpitchWithStreamedResponse:
@@ -413,6 +420,7 @@ class AsyncSpitchWithStreamedResponse:
         self.speech = speech.AsyncSpeechResourceWithStreamingResponse(client.speech)
         self.text = text.AsyncTextResourceWithStreamingResponse(client.text)
         self.files = files.AsyncFilesResourceWithStreamingResponse(client.files)
+        self.jobs = jobs.AsyncJobsResourceWithStreamingResponse(client.jobs)
 
 
 Client = Spitch

{spitch-1.39.0 → spitch-1.40.0}/src/spitch/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "spitch"
-__version__ = "1.39.0"  # x-release-please-version
+__version__ = "1.40.0"  # x-release-please-version

{spitch-1.39.0 → spitch-1.40.0}/src/spitch/resources/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .jobs import (
+    JobsResource,
+    AsyncJobsResource,
+    JobsResourceWithRawResponse,
+    AsyncJobsResourceWithRawResponse,
+    JobsResourceWithStreamingResponse,
+    AsyncJobsResourceWithStreamingResponse,
+)
 from .text import (
     TextResource,
     AsyncTextResource,
@@ -44,4 +52,10 @@ __all__ = [
     "AsyncFilesResourceWithRawResponse",
     "FilesResourceWithStreamingResponse",
     "AsyncFilesResourceWithStreamingResponse",
+    "JobsResource",
+    "AsyncJobsResource",
+    "JobsResourceWithRawResponse",
+    "AsyncJobsResourceWithRawResponse",
+    "JobsResourceWithStreamingResponse",
+    "AsyncJobsResourceWithStreamingResponse",
 ]

spitch-1.40.0/src/spitch/resources/jobs.py

@@ -0,0 +1,271 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import job_list_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..types.job import Job
+from ..pagination import SyncFilesCursor, AsyncFilesCursor
+from .._base_client import AsyncPaginator, make_request_options
+
+__all__ = ["JobsResource", "AsyncJobsResource"]
+
+
+class JobsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> JobsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/spi-tch/spitch-python#accessing-raw-response-data-eg-headers
+        """
+        return JobsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> JobsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/spi-tch/spitch-python#with_streaming_response
+        """
+        return JobsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        cursor: Optional[str] | Omit = omit,
+        limit: int | Omit = omit,
+        status: Optional[Literal["queued", "in_progress", "finished"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncFilesCursor[Job]:
+        """
+        Get Jobs
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/v1/jobs",
+            page=SyncFilesCursor[Job],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "cursor": cursor,
+                        "limit": limit,
+                        "status": status,
+                    },
+                    job_list_params.JobListParams,
+                ),
+            ),
+            model=Job,
+        )
+
+    def get(
+        self,
+        job_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Job:
+        """
+        Get Job
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not job_id:
+            raise ValueError(f"Expected a non-empty value for `job_id` but received {job_id!r}")
+        return self._get(
+            f"/v1/jobs/{job_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Job,
+        )
+
+
+class AsyncJobsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncJobsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/spi-tch/spitch-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncJobsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncJobsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/spi-tch/spitch-python#with_streaming_response
+        """
+        return AsyncJobsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        cursor: Optional[str] | Omit = omit,
+        limit: int | Omit = omit,
+        status: Optional[Literal["queued", "in_progress", "finished"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[Job, AsyncFilesCursor[Job]]:
+        """
+        Get Jobs
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/v1/jobs",
+            page=AsyncFilesCursor[Job],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "cursor": cursor,
+                        "limit": limit,
+                        "status": status,
+                    },
+                    job_list_params.JobListParams,
+                ),
+            ),
+            model=Job,
+        )
+
+    async def get(
+        self,
+        job_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Job:
+        """
+        Get Job
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not job_id:
+            raise ValueError(f"Expected a non-empty value for `job_id` but received {job_id!r}")
+        return await self._get(
+            f"/v1/jobs/{job_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Job,
+        )
+
+
+class JobsResourceWithRawResponse:
+    def __init__(self, jobs: JobsResource) -> None:
+        self._jobs = jobs
+
+        self.list = to_raw_response_wrapper(
+            jobs.list,
+        )
+        self.get = to_raw_response_wrapper(
+            jobs.get,
+        )
+
+
+class AsyncJobsResourceWithRawResponse:
+    def __init__(self, jobs: AsyncJobsResource) -> None:
+        self._jobs = jobs
+
+        self.list = async_to_raw_response_wrapper(
+            jobs.list,
+        )
+        self.get = async_to_raw_response_wrapper(
+            jobs.get,
+        )
+
+
+class JobsResourceWithStreamingResponse:
+    def __init__(self, jobs: JobsResource) -> None:
+        self._jobs = jobs
+
+        self.list = to_streamed_response_wrapper(
+            jobs.list,
+        )
+        self.get = to_streamed_response_wrapper(
+            jobs.get,
+        )
+
+
+class AsyncJobsResourceWithStreamingResponse:
+    def __init__(self, jobs: AsyncJobsResource) -> None:
+        self._jobs = jobs
+
+        self.list = async_to_streamed_response_wrapper(
+            jobs.list,
+        )
+        self.get = async_to_streamed_response_wrapper(
+            jobs.get,
+        )

{spitch-1.39.0 → spitch-1.40.0}/src/spitch/types/__init__.py

@@ -2,12 +2,15 @@
 
 from __future__ import annotations
 
+from .job import Job as Job
 from .file import File as File
+from .jobs import Jobs as Jobs
 from .files import Files as Files
 from .diacritics import Diacritics as Diacritics
 from .file_usage import FileUsage as FileUsage
 from .translation import Translation as Translation
 from .transcription import Transcription as Transcription
+from .job_list_params import JobListParams as JobListParams
 from .file_list_params import FileListParams as FileListParams
 from .file_upload_params import FileUploadParams as FileUploadParams
 from .file_download_params import FileDownloadParams as FileDownloadParams

spitch-1.40.0/src/spitch/types/job.py

@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+
+from .._models import BaseModel
+
+__all__ = ["Job"]
+
+
+class Job(BaseModel):
+    created_by: str
+
+    due_date: datetime
+
+    job_id: str
+
+    org_id: str
+
+    status: str

spitch-1.40.0/src/spitch/types/job_list_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["JobListParams"]
+
+
+class JobListParams(TypedDict, total=False):
+    cursor: Optional[str]
+
+    limit: int
+
+    status: Optional[Literal["queued", "in_progress", "finished"]]

spitch-1.40.0/src/spitch/types/jobs.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .job import Job
+from .._models import BaseModel
+
+__all__ = ["Jobs"]
+
+
+class Jobs(BaseModel):
+    items: List[Job]
+
+    next_cursor: Optional[str] = None

spitch-1.40.0/tests/api_resources/test_jobs.py

@@ -0,0 +1,169 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from spitch import Spitch, AsyncSpitch
+from tests.utils import assert_matches_type
+from spitch.types import Job
+from spitch.pagination import SyncFilesCursor, AsyncFilesCursor
+
+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_list(self, client: Spitch) -> None:
+        job = client.jobs.list()
+        assert_matches_type(SyncFilesCursor[Job], job, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: Spitch) -> None:
+        job = client.jobs.list(
+            cursor="cursor",
+            limit=99,
+            status="queued",
+        )
+        assert_matches_type(SyncFilesCursor[Job], job, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: Spitch) -> None:
+        response = client.jobs.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        job = response.parse()
+        assert_matches_type(SyncFilesCursor[Job], job, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: Spitch) -> None:
+        with client.jobs.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            job = response.parse()
+            assert_matches_type(SyncFilesCursor[Job], job, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_get(self, client: Spitch) -> None:
+        job = client.jobs.get(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+        assert_matches_type(Job, job, path=["response"])
+
+    @parametrize
+    def test_raw_response_get(self, client: Spitch) -> None:
+        response = client.jobs.with_raw_response.get(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        job = response.parse()
+        assert_matches_type(Job, job, path=["response"])
+
+    @parametrize
+    def test_streaming_response_get(self, client: Spitch) -> None:
+        with client.jobs.with_streaming_response.get(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            job = response.parse()
+            assert_matches_type(Job, job, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_get(self, client: Spitch) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `job_id` but received ''"):
+            client.jobs.with_raw_response.get(
+                "",
+            )
+
+
+class TestAsyncJobs:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncSpitch) -> None:
+        job = await async_client.jobs.list()
+        assert_matches_type(AsyncFilesCursor[Job], job, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncSpitch) -> None:
+        job = await async_client.jobs.list(
+            cursor="cursor",
+            limit=99,
+            status="queued",
+        )
+        assert_matches_type(AsyncFilesCursor[Job], job, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncSpitch) -> None:
+        response = await async_client.jobs.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        job = await response.parse()
+        assert_matches_type(AsyncFilesCursor[Job], job, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncSpitch) -> None:
+        async with async_client.jobs.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            job = await response.parse()
+            assert_matches_type(AsyncFilesCursor[Job], job, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_get(self, async_client: AsyncSpitch) -> None:
+        job = await async_client.jobs.get(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+        assert_matches_type(Job, job, path=["response"])
+
+    @parametrize
+    async def test_raw_response_get(self, async_client: AsyncSpitch) -> None:
+        response = await async_client.jobs.with_raw_response.get(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        job = await response.parse()
+        assert_matches_type(Job, job, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_get(self, async_client: AsyncSpitch) -> None:
+        async with async_client.jobs.with_streaming_response.get(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            job = await response.parse()
+            assert_matches_type(Job, job, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_get(self, async_client: AsyncSpitch) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `job_id` but received ''"):
+            await async_client.jobs.with_raw_response.get(
+                "",
+            )

spitch-1.39.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "1.39.0"
-}