opengradient 0.5.10__tar.gz → 0.5.11__tar.gz

{opengradient-0.5.10/src/opengradient.egg-info → opengradient-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opengradient
-Version: 0.5.10
+Version: 0.5.11
 Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <kyle@vannalabs.ai>
 License-Expression: MIT

{opengradient-0.5.10 → opengradient-0.5.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opengradient"
-version = "0.5.10"
+version = "0.5.11"
 description = "Python SDK for OpenGradient decentralized model management & inference services"
 authors = [{name = "OpenGradient", email = "kyle@vannalabs.ai"}]
 readme = "README.md"

{opengradient-0.5.10 → opengradient-0.5.11}/src/opengradient/client.py

@@ -1152,7 +1152,7 @@ class Client:
                 limits=LIMITS,
                 http2=False,
                 follow_redirects=False,
-                auth=X402Auth(account=self._wallet_account),  # type: ignore
+                auth=X402Auth(account=self._wallet_account, network_filter=DEFAULT_NETWORK_FILTER),  # type: ignore
             ) as client:
                 headers = {
                     "Content-Type": "application/json",

opengradient-0.5.11/src/opengradient/x402_auth.py

@@ -0,0 +1,99 @@
+"""
+X402 Authentication handler for httpx streaming requests.
+
+This module provides an httpx Auth class that handles x402 payment protocol
+authentication for streaming responses.
+"""
+
+import httpx
+import typing
+import logging
+
+from x402.clients.base import x402Client
+from x402.types import x402PaymentRequiredResponse, PaymentRequirements
+
+
+class X402Auth(httpx.Auth):
+    """
+    httpx Auth handler for x402 payment protocol.
+
+    This class implements the httpx Auth interface to handle 402 Payment Required
+    responses by automatically creating and attaching payment headers.
+
+    Example:
+        async with httpx.AsyncClient(auth=X402Auth(account=wallet_account)) as client:
+            response = await client.get("https://api.example.com/paid-resource")
+    """
+
+    requires_response_body = True
+
+    def __init__(
+        self,
+        account: typing.Any,
+        max_value: typing.Optional[int] = None,
+        payment_requirements_selector: typing.Optional[
+            typing.Callable[
+                [
+                    list[PaymentRequirements],
+                    typing.Optional[str],
+                    typing.Optional[str],
+                    typing.Optional[int],
+                ],
+                PaymentRequirements,
+            ]
+        ] = None,
+        network_filter: typing.Optional[str] = None,
+    ):
+        """
+        Initialize X402Auth with an Ethereum account for signing payments.
+
+        Args:
+            account: eth_account LocalAccount instance for signing payments
+            max_value: Optional maximum allowed payment amount in base units
+            network_filter: Optional network filter for selecting payment requirements
+            scheme_filter: Optional scheme filter for selecting payment requirements
+        """
+        self.x402_client = x402Client(
+            account,
+            max_value=max_value,
+            payment_requirements_selector=payment_requirements_selector,  # type: ignore
+        )
+        self.network_filter = network_filter
+
+    async def async_auth_flow(
+        self, request: httpx.Request
+    ) -> typing.AsyncGenerator[httpx.Request, httpx.Response]:
+        """
+        Handle authentication flow for x402 payment protocol.
+
+        Args:
+            request: httpx Request object to be authenticated
+
+        Yields:
+            httpx Request object with authentication headers attached
+        """
+        response = yield request
+
+        if response.status_code == 402:
+            try:
+                await response.aread()
+                data = response.json()
+
+                payment_response = x402PaymentRequiredResponse(**data)
+
+                selected_requirements = self.x402_client.select_payment_requirements(
+                    payment_response.accepts,
+                    self.network_filter,
+                )
+
+                payment_header = self.x402_client.create_payment_header(
+                    selected_requirements, payment_response.x402_version
+                )
+
+                request.headers["X-Payment"] = payment_header
+                request.headers["Access-Control-Expose-Headers"] = "X-Payment-Response"
+                yield request
+
+            except Exception as e:
+                logging.error(f"X402Auth: Error handling payment: {e}")
+                return

{opengradient-0.5.10 → opengradient-0.5.11/src/opengradient.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opengradient
-Version: 0.5.10
+Version: 0.5.11
 Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <kyle@vannalabs.ai>
 License-Expression: MIT

opengradient-0.5.10/src/opengradient/x402_auth.py

@@ -1,102 +0,0 @@
-"""
-X402 Authentication handler for httpx streaming requests.
-
-This module provides an httpx Auth class that handles x402 payment protocol
-authentication for streaming responses.
-"""
-
-from typing import Generator, Optional
-
-import httpx
-from eth_account.account import LocalAccount
-from x402.clients.base import x402Client
-from x402.types import x402PaymentRequiredResponse
-
-
-class X402Auth(httpx.Auth):
-    """
-    httpx Auth handler for x402 payment protocol.
-
-    This class implements the httpx Auth interface to handle 402 Payment Required
-    responses by automatically creating and attaching payment headers.
-
-    Example:
-        async with httpx.AsyncClient(auth=X402Auth(account=wallet_account)) as client:
-            response = await client.get("https://api.example.com/paid-resource")
-    """
-
-    requires_response_body = True
-
-    def __init__(
-        self,
-        account: LocalAccount,
-        max_value: Optional[int] = None,
-        network_filter: Optional[str] = None,
-        scheme_filter: Optional[str] = None,
-    ):
-        """
-        Initialize X402Auth with an Ethereum account for signing payments.
-
-        Args:
-            account: eth_account LocalAccount instance for signing payments
-            max_value: Optional maximum allowed payment amount in base units
-            network_filter: Optional network filter for selecting payment requirements
-            scheme_filter: Optional scheme filter for selecting payment requirements
-        """
-        self._account = account
-        self._max_value = max_value
-        self._network_filter = network_filter
-        self._scheme_filter = scheme_filter
-        self._x402_client = x402Client(
-            account,
-            max_value=max_value,
-            network_filter=network_filter,
-            scheme_filter=scheme_filter,
-        )
-
-    def auth_flow(
-        self, request: httpx.Request
-    ) -> Generator[httpx.Request, httpx.Response, None]:
-        """
-        Implement the auth flow for x402 payment handling.
-
-        This method yields the initial request, and if a 402 response is received,
-        it creates a payment header and retries the request.
-
-        Args:
-            request: The initial httpx Request
-
-        Yields:
-            httpx.Request objects (initial and retry with payment header)
-        """
-        # Send the initial request
-        response = yield request
-
-        # If not a 402, we're done
-        if response.status_code != 402:
-            return
-
-        # Handle 402 Payment Required
-        try:
-            data = response.json()
-            payment_response = x402PaymentRequiredResponse(**data)
-
-            # Select payment requirements
-            selected_requirements = self._x402_client.select_payment_requirements(
-                payment_response.accepts
-            )
-
-            # Create payment header
-            payment_header = self._x402_client.create_payment_header(
-                selected_requirements, payment_response.x402_version
-            )
-
-            # Add payment header and retry
-            request.headers["X-Payment"] = payment_header
-            request.headers["Access-Control-Expose-Headers"] = "X-Payment-Response"
-
-            yield request
-
-        except Exception:
-            # If payment handling fails, just return the original 402 response
-            return