telnyx 3.9.0__py3-none-any.whl → 3.11.0__py3-none-any.whl

telnyx/_streaming.py

@@ -57,9 +57,8 @@ class Stream(Generic[_T]):
         for sse in iterator:
             yield process_data(data=sse.json(), cast_to=cast_to, response=response)
 
-        # Ensure the entire stream is consumed
-        for _sse in iterator:
-            ...
+        # As we might not fully consume the response stream, we need to close it explicitly
+        response.close()
 
     def __enter__(self) -> Self:
         return self
@@ -121,9 +120,8 @@ class AsyncStream(Generic[_T]):
         async for sse in iterator:
             yield process_data(data=sse.json(), cast_to=cast_to, response=response)
 
-        # Ensure the entire stream is consumed
-        async for _sse in iterator:
-            ...
+        # As we might not fully consume the response stream, we need to close it explicitly
+        await response.aclose()
 
     async def __aenter__(self) -> Self:
         return self

telnyx/_version.py

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

telnyx/resources/__init__.py

@@ -224,7 +224,7 @@ from .portouts import (
     PortoutsResourceWithStreamingResponse,
     AsyncPortoutsResourceWithStreamingResponse,
 )
-from .webhooks import TelnyxWebhook, WebhooksResource, AsyncWebhooksResource, TelnyxWebhookVerificationError
+from .webhooks import WebhooksResource, AsyncWebhooksResource, TelnyxWebhookVerificationError
 from .wireless import (
     WirelessResource,
     AsyncWirelessResource,
@@ -1237,7 +1237,6 @@ __all__ = [
     "AsyncOAuthGrantsResourceWithStreamingResponse",
     "WebhooksResource",
     "AsyncWebhooksResource",
-    "TelnyxWebhook",
     "TelnyxWebhookVerificationError",
     "AccessIPAddressResource",
     "AsyncAccessIPAddressResource",

telnyx/resources/ai/__init__.py

@@ -56,6 +56,22 @@ from .fine_tuning import (
     FineTuningResourceWithStreamingResponse,
     AsyncFineTuningResourceWithStreamingResponse,
 )
+from .mcp_servers import (
+    McpServersResource,
+    AsyncMcpServersResource,
+    McpServersResourceWithRawResponse,
+    AsyncMcpServersResourceWithRawResponse,
+    McpServersResourceWithStreamingResponse,
+    AsyncMcpServersResourceWithStreamingResponse,
+)
+from .integrations import (
+    IntegrationsResource,
+    AsyncIntegrationsResource,
+    IntegrationsResourceWithRawResponse,
+    AsyncIntegrationsResourceWithRawResponse,
+    IntegrationsResourceWithStreamingResponse,
+    AsyncIntegrationsResourceWithStreamingResponse,
+)
 from .conversations import (
     ConversationsResource,
     AsyncConversationsResource,
@@ -108,6 +124,18 @@ __all__ = [
     "AsyncFineTuningResourceWithRawResponse",
     "FineTuningResourceWithStreamingResponse",
     "AsyncFineTuningResourceWithStreamingResponse",
+    "IntegrationsResource",
+    "AsyncIntegrationsResource",
+    "IntegrationsResourceWithRawResponse",
+    "AsyncIntegrationsResourceWithRawResponse",
+    "IntegrationsResourceWithStreamingResponse",
+    "AsyncIntegrationsResourceWithStreamingResponse",
+    "McpServersResource",
+    "AsyncMcpServersResource",
+    "McpServersResourceWithRawResponse",
+    "AsyncMcpServersResourceWithRawResponse",
+    "McpServersResourceWithStreamingResponse",
+    "AsyncMcpServersResourceWithStreamingResponse",
     "AIResource",
     "AsyncAIResource",
     "AIResourceWithRawResponse",

telnyx/resources/ai/ai.py

@@ -39,6 +39,14 @@ from ..._response import (
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
+from .mcp_servers import (
+    McpServersResource,
+    AsyncMcpServersResource,
+    McpServersResourceWithRawResponse,
+    AsyncMcpServersResourceWithRawResponse,
+    McpServersResourceWithStreamingResponse,
+    AsyncMcpServersResourceWithStreamingResponse,
+)
 from ..._base_client import make_request_options
 from .assistants.assistants import (
     AssistantsResource,
@@ -64,6 +72,14 @@ from .fine_tuning.fine_tuning import (
     FineTuningResourceWithStreamingResponse,
     AsyncFineTuningResourceWithStreamingResponse,
 )
+from .integrations.integrations import (
+    IntegrationsResource,
+    AsyncIntegrationsResource,
+    IntegrationsResourceWithRawResponse,
+    AsyncIntegrationsResourceWithRawResponse,
+    IntegrationsResourceWithStreamingResponse,
+    AsyncIntegrationsResourceWithStreamingResponse,
+)
 from .conversations.conversations import (
     ConversationsResource,
     AsyncConversationsResource,
@@ -107,6 +123,14 @@ class AIResource(SyncAPIResource):
     def fine_tuning(self) -> FineTuningResource:
         return FineTuningResource(self._client)
 
+    @cached_property
+    def integrations(self) -> IntegrationsResource:
+        return IntegrationsResource(self._client)
+
+    @cached_property
+    def mcp_servers(self) -> McpServersResource:
+        return McpServersResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AIResourceWithRawResponse:
         """
@@ -238,6 +262,14 @@ class AsyncAIResource(AsyncAPIResource):
     def fine_tuning(self) -> AsyncFineTuningResource:
         return AsyncFineTuningResource(self._client)
 
+    @cached_property
+    def integrations(self) -> AsyncIntegrationsResource:
+        return AsyncIntegrationsResource(self._client)
+
+    @cached_property
+    def mcp_servers(self) -> AsyncMcpServersResource:
+        return AsyncMcpServersResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncAIResourceWithRawResponse:
         """
@@ -379,6 +411,14 @@ class AIResourceWithRawResponse:
     def fine_tuning(self) -> FineTuningResourceWithRawResponse:
         return FineTuningResourceWithRawResponse(self._ai.fine_tuning)
 
+    @cached_property
+    def integrations(self) -> IntegrationsResourceWithRawResponse:
+        return IntegrationsResourceWithRawResponse(self._ai.integrations)
+
+    @cached_property
+    def mcp_servers(self) -> McpServersResourceWithRawResponse:
+        return McpServersResourceWithRawResponse(self._ai.mcp_servers)
+
 
 class AsyncAIResourceWithRawResponse:
     def __init__(self, ai: AsyncAIResource) -> None:
@@ -419,6 +459,14 @@ class AsyncAIResourceWithRawResponse:
     def fine_tuning(self) -> AsyncFineTuningResourceWithRawResponse:
         return AsyncFineTuningResourceWithRawResponse(self._ai.fine_tuning)
 
+    @cached_property
+    def integrations(self) -> AsyncIntegrationsResourceWithRawResponse:
+        return AsyncIntegrationsResourceWithRawResponse(self._ai.integrations)
+
+    @cached_property
+    def mcp_servers(self) -> AsyncMcpServersResourceWithRawResponse:
+        return AsyncMcpServersResourceWithRawResponse(self._ai.mcp_servers)
+
 
 class AIResourceWithStreamingResponse:
     def __init__(self, ai: AIResource) -> None:
@@ -459,6 +507,14 @@ class AIResourceWithStreamingResponse:
     def fine_tuning(self) -> FineTuningResourceWithStreamingResponse:
         return FineTuningResourceWithStreamingResponse(self._ai.fine_tuning)
 
+    @cached_property
+    def integrations(self) -> IntegrationsResourceWithStreamingResponse:
+        return IntegrationsResourceWithStreamingResponse(self._ai.integrations)
+
+    @cached_property
+    def mcp_servers(self) -> McpServersResourceWithStreamingResponse:
+        return McpServersResourceWithStreamingResponse(self._ai.mcp_servers)
+
 
 class AsyncAIResourceWithStreamingResponse:
     def __init__(self, ai: AsyncAIResource) -> None:
@@ -498,3 +554,11 @@ class AsyncAIResourceWithStreamingResponse:
     @cached_property
     def fine_tuning(self) -> AsyncFineTuningResourceWithStreamingResponse:
         return AsyncFineTuningResourceWithStreamingResponse(self._ai.fine_tuning)
+
+    @cached_property
+    def integrations(self) -> AsyncIntegrationsResourceWithStreamingResponse:
+        return AsyncIntegrationsResourceWithStreamingResponse(self._ai.integrations)
+
+    @cached_property
+    def mcp_servers(self) -> AsyncMcpServersResourceWithStreamingResponse:
+        return AsyncMcpServersResourceWithStreamingResponse(self._ai.mcp_servers)

telnyx/resources/ai/integrations/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .connections import (
+    ConnectionsResource,
+    AsyncConnectionsResource,
+    ConnectionsResourceWithRawResponse,
+    AsyncConnectionsResourceWithRawResponse,
+    ConnectionsResourceWithStreamingResponse,
+    AsyncConnectionsResourceWithStreamingResponse,
+)
+from .integrations import (
+    IntegrationsResource,
+    AsyncIntegrationsResource,
+    IntegrationsResourceWithRawResponse,
+    AsyncIntegrationsResourceWithRawResponse,
+    IntegrationsResourceWithStreamingResponse,
+    AsyncIntegrationsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "ConnectionsResource",
+    "AsyncConnectionsResource",
+    "ConnectionsResourceWithRawResponse",
+    "AsyncConnectionsResourceWithRawResponse",
+    "ConnectionsResourceWithStreamingResponse",
+    "AsyncConnectionsResourceWithStreamingResponse",
+    "IntegrationsResource",
+    "AsyncIntegrationsResource",
+    "IntegrationsResourceWithRawResponse",
+    "AsyncIntegrationsResourceWithRawResponse",
+    "IntegrationsResourceWithStreamingResponse",
+    "AsyncIntegrationsResourceWithStreamingResponse",
+]

telnyx/resources/ai/integrations/connections.py

@@ -0,0 +1,294 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ...._types import Body, Query, Headers, NoneType, NotGiven, not_given
+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 ...._base_client import make_request_options
+from ....types.ai.integrations.connection_list_response import ConnectionListResponse
+from ....types.ai.integrations.connection_retrieve_response import ConnectionRetrieveResponse
+
+__all__ = ["ConnectionsResource", "AsyncConnectionsResource"]
+
+
+class ConnectionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ConnectionsResourceWithRawResponse:
+        """
+        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/team-telnyx/telnyx-python#accessing-raw-response-data-eg-headers
+        """
+        return ConnectionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ConnectionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/team-telnyx/telnyx-python#with_streaming_response
+        """
+        return ConnectionsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        user_connection_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,
+    ) -> ConnectionRetrieveResponse:
+        """
+        Get user setup integrations
+
+        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 user_connection_id:
+            raise ValueError(f"Expected a non-empty value for `user_connection_id` but received {user_connection_id!r}")
+        return self._get(
+            f"/ai/integrations/connections/{user_connection_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ConnectionRetrieveResponse,
+        )
+
+    def list(
+        self,
+        *,
+        # 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,
+    ) -> ConnectionListResponse:
+        """List user setup integrations"""
+        return self._get(
+            "/ai/integrations/connections",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ConnectionListResponse,
+        )
+
+    def delete(
+        self,
+        user_connection_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,
+    ) -> None:
+        """
+        Delete a specific integration connection.
+
+        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 user_connection_id:
+            raise ValueError(f"Expected a non-empty value for `user_connection_id` but received {user_connection_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/ai/integrations/connections/{user_connection_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncConnectionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncConnectionsResourceWithRawResponse:
+        """
+        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/team-telnyx/telnyx-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncConnectionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncConnectionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/team-telnyx/telnyx-python#with_streaming_response
+        """
+        return AsyncConnectionsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        user_connection_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,
+    ) -> ConnectionRetrieveResponse:
+        """
+        Get user setup integrations
+
+        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 user_connection_id:
+            raise ValueError(f"Expected a non-empty value for `user_connection_id` but received {user_connection_id!r}")
+        return await self._get(
+            f"/ai/integrations/connections/{user_connection_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ConnectionRetrieveResponse,
+        )
+
+    async def list(
+        self,
+        *,
+        # 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,
+    ) -> ConnectionListResponse:
+        """List user setup integrations"""
+        return await self._get(
+            "/ai/integrations/connections",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ConnectionListResponse,
+        )
+
+    async def delete(
+        self,
+        user_connection_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,
+    ) -> None:
+        """
+        Delete a specific integration connection.
+
+        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 user_connection_id:
+            raise ValueError(f"Expected a non-empty value for `user_connection_id` but received {user_connection_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/ai/integrations/connections/{user_connection_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class ConnectionsResourceWithRawResponse:
+    def __init__(self, connections: ConnectionsResource) -> None:
+        self._connections = connections
+
+        self.retrieve = to_raw_response_wrapper(
+            connections.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            connections.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            connections.delete,
+        )
+
+
+class AsyncConnectionsResourceWithRawResponse:
+    def __init__(self, connections: AsyncConnectionsResource) -> None:
+        self._connections = connections
+
+        self.retrieve = async_to_raw_response_wrapper(
+            connections.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            connections.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            connections.delete,
+        )
+
+
+class ConnectionsResourceWithStreamingResponse:
+    def __init__(self, connections: ConnectionsResource) -> None:
+        self._connections = connections
+
+        self.retrieve = to_streamed_response_wrapper(
+            connections.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            connections.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            connections.delete,
+        )
+
+
+class AsyncConnectionsResourceWithStreamingResponse:
+    def __init__(self, connections: AsyncConnectionsResource) -> None:
+        self._connections = connections
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            connections.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            connections.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            connections.delete,
+        )