opengradient 0.5.9__py3-none-any.whl → 0.5.10__py3-none-any.whl

opengradient/__init__.py

@@ -23,9 +23,13 @@ from .types import (
     FileUploadResult,
     x402SettlementMode,
 )
+from .alpha import _AlphaNamespace
 
 from . import llm, alphasense
 
+# Module-level alpha namespace for workflow/ML execution features (Alpha Testnet only)
+alpha = _AlphaNamespace()
+
 _client = None
 
 
@@ -284,93 +288,6 @@ def list_files(model_name: str, version: str) -> List[Dict]:
     return _client.list_files(model_name, version)
 
 
-def new_workflow(
-    model_cid: str,
-    input_query: HistoricalInputQuery,
-    input_tensor_name: str,
-    scheduler_params: Optional[SchedulerParams] = None,
-) -> str:
-    """
-    Deploy a new workflow contract with the specified parameters.
-
-    This function deploys a new workflow contract and optionally registers it with
-    the scheduler for automated execution. If scheduler_params is not provided,
-    the workflow will be deployed without automated execution scheduling.
-
-    Args:
-        model_cid: IPFS CID of the model
-        input_query: HistoricalInputQuery containing query parameters
-        input_tensor_name: Name of the input tensor
-        scheduler_params: Optional scheduler configuration as SchedulerParams instance
-            If not provided, the workflow will be deployed without scheduling.
-
-    Returns:
-        str: Deployed contract address. If scheduler_params was provided, the workflow
-             will be automatically executed according to the specified schedule.
-    """
-    if _client is None:
-        raise RuntimeError("OpenGradient client not initialized. Call og.init(...) first.")
-
-    return _client.new_workflow(
-        model_cid=model_cid, input_query=input_query, input_tensor_name=input_tensor_name, scheduler_params=scheduler_params
-    )
-
-
-def read_workflow_result(contract_address: str) -> ModelOutput:
-    """
-    Reads the latest inference result from a deployed workflow contract.
-
-    This function retrieves the most recent output from a deployed model executor contract.
-    It includes built-in retry logic to handle blockchain state delays.
-
-    Args:
-        contract_address (str): Address of the deployed workflow contract
-
-    Returns:
-        Dict[str, Union[str, Dict]]: A dictionary containing:
-            - status: "success" or "error"
-            - result: The model output data if successful
-            - error: Error message if status is "error"
-
-    Raises:
-        RuntimeError: If OpenGradient client is not initialized
-    """
-    if _client is None:
-        raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.read_workflow_result(contract_address)
-
-
-def run_workflow(contract_address: str) -> ModelOutput:
-    """
-    Executes the workflow by calling run() on the contract to pull latest data and perform inference.
-
-    Args:
-        contract_address (str): Address of the deployed workflow contract
-
-    Returns:
-        Dict[str, Union[str, Dict]]: Status of the run operation
-    """
-    if _client is None:
-        raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.run_workflow(contract_address)
-
-
-def read_workflow_history(contract_address: str, num_results: int) -> List[ModelOutput]:
-    """
-    Gets historical inference results from a workflow contract.
-
-    Args:
-        contract_address (str): Address of the deployed workflow contract
-        num_results (int): Number of historical results to retrieve
-
-    Returns:
-        List[Dict]: List of historical inference results
-    """
-    if _client is None:
-        raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.read_workflow_history(contract_address, num_results)
-
-
 __all__ = [
     "list_files",
     "login",
@@ -383,10 +300,7 @@ __all__ = [
     "init",
     "LLM",
     "TEE_LLM",
-    "new_workflow",
-    "read_workflow_result",
-    "run_workflow",
-    "read_workflow_history",
+    "alpha",
     "InferenceMode",
     "LlmInferenceMode",
     "HistoricalInputQuery",

opengradient/alpha.py

@@ -0,0 +1,375 @@
+"""
+Alpha Testnet features for OpenGradient SDK.
+
+This module contains features that are only available on the Alpha Testnet,
+including workflow management and ML model execution.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional
+
+from web3 import Web3
+from web3.exceptions import ContractLogicError
+
+from .defaults import DEFAULT_SCHEDULER_ADDRESS
+from .types import HistoricalInputQuery, ModelOutput, SchedulerParams
+from .utils import convert_array_to_model_output
+
+if TYPE_CHECKING:
+    from .client import Client
+
+# How much time we wait for txn to be included in chain
+INFERENCE_TX_TIMEOUT = 120
+REGULAR_TX_TIMEOUT = 30
+
+
+class Alpha:
+    """
+    Alpha Testnet features namespace.
+
+    This class provides access to features that are only available on the Alpha Testnet,
+    including workflow deployment and execution.
+
+    Usage:
+        client = og.new_client(...)
+        result = client.alpha.new_workflow(model_cid, input_query, input_tensor_name)
+    """
+
+    def __init__(self, client: "Client"):
+        self._client = client
+
+    def _get_abi(self, abi_name: str) -> dict:
+        """Returns the ABI for the requested contract."""
+        abi_path = Path(__file__).parent / "abi" / abi_name
+        with open(abi_path, "r") as f:
+            return json.load(f)
+
+    def _get_bin(self, bin_name: str) -> str:
+        """Returns the bin for the requested contract."""
+        bin_path = Path(__file__).parent / "bin" / bin_name
+        with open(bin_path, "r", encoding="utf-8") as f:
+            bytecode = f.read().strip()
+            if not bytecode.startswith("0x"):
+                bytecode = "0x" + bytecode
+            return bytecode
+
+    def new_workflow(
+        self,
+        model_cid: str,
+        input_query: HistoricalInputQuery,
+        input_tensor_name: str,
+        scheduler_params: Optional[SchedulerParams] = None,
+    ) -> str:
+        """
+        Deploy a new workflow contract with the specified parameters.
+
+        This function deploys a new workflow contract on OpenGradient that connects
+        an AI model with its required input data. When executed, the workflow will fetch
+        the specified model, evaluate the input query to get data, and perform inference.
+
+        The workflow can be set to execute manually or automatically via a scheduler.
+
+        Args:
+            model_cid (str): CID of the model to be executed from the Model Hub
+            input_query (HistoricalInputQuery): Input definition for the model inference,
+                will be evaluated at runtime for each inference
+            input_tensor_name (str): Name of the input tensor expected by the model
+            scheduler_params (Optional[SchedulerParams]): Scheduler configuration for automated execution:
+                - frequency: Execution frequency in seconds
+                - duration_hours: How long the schedule should live for
+
+        Returns:
+            str: Deployed contract address. If scheduler_params was provided, the workflow
+                 will be automatically executed according to the specified schedule.
+
+        Raises:
+            Exception: If transaction fails or gas estimation fails
+        """
+        from .client import run_with_retry
+
+        # Get contract ABI and bytecode
+        abi = self._get_abi("PriceHistoryInference.abi")
+        bytecode = self._get_bin("PriceHistoryInference.bin")
+
+        def deploy_transaction():
+            contract = self._client._blockchain.eth.contract(abi=abi, bytecode=bytecode)
+            query_tuple = input_query.to_abi_format()
+            constructor_args = [model_cid, input_tensor_name, query_tuple]
+
+            try:
+                # Estimate gas needed
+                estimated_gas = contract.constructor(*constructor_args).estimate_gas(
+                    {"from": self._client._wallet_account.address}
+                )
+                gas_limit = int(estimated_gas * 1.2)
+            except Exception as e:
+                print(f"⚠️ Gas estimation failed: {str(e)}")
+                gas_limit = 5000000  # Conservative fallback
+                print(f"📊 Using fallback gas limit: {gas_limit}")
+
+            transaction = contract.constructor(*constructor_args).build_transaction(
+                {
+                    "from": self._client._wallet_account.address,
+                    "nonce": self._client._blockchain.eth.get_transaction_count(
+                        self._client._wallet_account.address, "pending"
+                    ),
+                    "gas": gas_limit,
+                    "gasPrice": self._client._blockchain.eth.gas_price,
+                    "chainId": self._client._blockchain.eth.chain_id,
+                }
+            )
+
+            signed_txn = self._client._wallet_account.sign_transaction(transaction)
+            tx_hash = self._client._blockchain.eth.send_raw_transaction(signed_txn.raw_transaction)
+
+            tx_receipt = self._client._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
+
+            if tx_receipt["status"] == 0:
+                raise Exception(f"❌ Contract deployment failed, transaction hash: {tx_hash.hex()}")
+
+            return tx_receipt.contractAddress
+
+        contract_address = run_with_retry(deploy_transaction)
+
+        if scheduler_params:
+            self._register_with_scheduler(contract_address, scheduler_params)
+
+        return contract_address
+
+    def _register_with_scheduler(self, contract_address: str, scheduler_params: SchedulerParams) -> None:
+        """
+        Register the deployed workflow contract with the scheduler for automated execution.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+            scheduler_params (SchedulerParams): Scheduler configuration containing:
+                - frequency: Execution frequency in seconds
+                - duration_hours: How long to run in hours
+                - end_time: Unix timestamp when scheduling should end
+
+        Raises:
+            Exception: If registration with scheduler fails. The workflow contract will
+                      still be deployed and can be executed manually.
+        """
+        scheduler_abi = self._get_abi("WorkflowScheduler.abi")
+
+        # Scheduler contract address
+        scheduler_address = DEFAULT_SCHEDULER_ADDRESS
+        scheduler_contract = self._client._blockchain.eth.contract(address=scheduler_address, abi=scheduler_abi)
+
+        try:
+            # Register the workflow with the scheduler
+            scheduler_tx = scheduler_contract.functions.registerTask(
+                contract_address, scheduler_params.end_time, scheduler_params.frequency
+            ).build_transaction(
+                {
+                    "from": self._client._wallet_account.address,
+                    "gas": 300000,
+                    "gasPrice": self._client._blockchain.eth.gas_price,
+                    "nonce": self._client._blockchain.eth.get_transaction_count(
+                        self._client._wallet_account.address, "pending"
+                    ),
+                    "chainId": self._client._blockchain.eth.chain_id,
+                }
+            )
+
+            signed_scheduler_tx = self._client._wallet_account.sign_transaction(scheduler_tx)
+            scheduler_tx_hash = self._client._blockchain.eth.send_raw_transaction(signed_scheduler_tx.raw_transaction)
+            self._client._blockchain.eth.wait_for_transaction_receipt(scheduler_tx_hash, timeout=REGULAR_TX_TIMEOUT)
+        except Exception as e:
+            print(f"❌ Error registering contract with scheduler: {str(e)}")
+            print("  The workflow contract is still deployed and can be executed manually.")
+
+    def read_workflow_result(self, contract_address: str) -> ModelOutput:
+        """
+        Reads the latest inference result from a deployed workflow contract.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+
+        Returns:
+            ModelOutput: The inference result from the contract
+
+        Raises:
+            ContractLogicError: If the transaction fails
+            Web3Error: If there are issues with the web3 connection or contract interaction
+        """
+        # Get the contract interface
+        contract = self._client._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
+
+        # Get the result
+        result = contract.functions.getInferenceResult().call()
+
+        return convert_array_to_model_output(result)
+
+    def run_workflow(self, contract_address: str) -> ModelOutput:
+        """
+        Triggers the run() function on a deployed workflow contract and returns the result.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+
+        Returns:
+            ModelOutput: The inference result from the contract
+
+        Raises:
+            ContractLogicError: If the transaction fails
+            Web3Error: If there are issues with the web3 connection or contract interaction
+        """
+        # Get the contract interface
+        contract = self._client._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
+
+        # Call run() function
+        nonce = self._client._blockchain.eth.get_transaction_count(self._client._wallet_account.address, "pending")
+
+        run_function = contract.functions.run()
+        transaction = run_function.build_transaction(
+            {
+                "from": self._client._wallet_account.address,
+                "nonce": nonce,
+                "gas": 30000000,
+                "gasPrice": self._client._blockchain.eth.gas_price,
+                "chainId": self._client._blockchain.eth.chain_id,
+            }
+        )
+
+        signed_txn = self._client._wallet_account.sign_transaction(transaction)
+        tx_hash = self._client._blockchain.eth.send_raw_transaction(signed_txn.raw_transaction)
+        tx_receipt = self._client._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=INFERENCE_TX_TIMEOUT)
+
+        if tx_receipt.status == 0:
+            raise ContractLogicError(f"Run transaction failed. Receipt: {tx_receipt}")
+
+        # Get the inference result from the contract
+        result = contract.functions.getInferenceResult().call()
+
+        return convert_array_to_model_output(result)
+
+    def read_workflow_history(self, contract_address: str, num_results: int) -> List[ModelOutput]:
+        """
+        Gets historical inference results from a workflow contract.
+
+        Retrieves the specified number of most recent inference results from the contract's
+        storage, with the most recent result first.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+            num_results (int): Number of historical results to retrieve
+
+        Returns:
+            List[ModelOutput]: List of historical inference results
+        """
+        contract = self._client._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
+
+        results = contract.functions.getLastInferenceResults(num_results).call()
+        return [convert_array_to_model_output(result) for result in results]
+
+
+class _AlphaNamespace:
+    """
+    Module-level alpha namespace for use with og.init().
+
+    Usage:
+        og.init(...)
+        result = og.alpha.new_workflow(model_cid, input_query, input_tensor_name)
+    """
+
+    def new_workflow(
+        self,
+        model_cid: str,
+        input_query: HistoricalInputQuery,
+        input_tensor_name: str,
+        scheduler_params: Optional[SchedulerParams] = None,
+    ) -> str:
+        """
+        Deploy a new workflow contract with the specified parameters.
+
+        This function deploys a new workflow contract and optionally registers it with
+        the scheduler for automated execution. If scheduler_params is not provided,
+        the workflow will be deployed without automated execution scheduling.
+
+        Args:
+            model_cid: IPFS CID of the model
+            input_query: HistoricalInputQuery containing query parameters
+            input_tensor_name: Name of the input tensor
+            scheduler_params: Optional scheduler configuration as SchedulerParams instance
+                If not provided, the workflow will be deployed without scheduling.
+
+        Returns:
+            str: Deployed contract address. If scheduler_params was provided, the workflow
+                 will be automatically executed according to the specified schedule.
+        """
+        from . import _client
+
+        if _client is None:
+            raise RuntimeError("OpenGradient client not initialized. Call og.init(...) first.")
+
+        return _client.alpha.new_workflow(
+            model_cid=model_cid,
+            input_query=input_query,
+            input_tensor_name=input_tensor_name,
+            scheduler_params=scheduler_params,
+        )
+
+    def read_workflow_result(self, contract_address: str) -> ModelOutput:
+        """
+        Reads the latest inference result from a deployed workflow contract.
+
+        This function retrieves the most recent output from a deployed model executor contract.
+        It includes built-in retry logic to handle blockchain state delays.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+
+        Returns:
+            ModelOutput: The inference result from the contract
+
+        Raises:
+            RuntimeError: If OpenGradient client is not initialized
+        """
+        from . import _client
+
+        if _client is None:
+            raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
+        return _client.alpha.read_workflow_result(contract_address)
+
+    def run_workflow(self, contract_address: str) -> ModelOutput:
+        """
+        Executes the workflow by calling run() on the contract to pull latest data and perform inference.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+
+        Returns:
+            ModelOutput: The inference result from the contract
+        """
+        from . import _client
+
+        if _client is None:
+            raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
+        return _client.alpha.run_workflow(contract_address)
+
+    def read_workflow_history(self, contract_address: str, num_results: int) -> List[ModelOutput]:
+        """
+        Gets historical inference results from a workflow contract.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+            num_results (int): Number of historical results to retrieve
+
+        Returns:
+            List[ModelOutput]: List of historical inference results
+        """
+        from . import _client
+
+        if _client is None:
+            raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
+        return _client.alpha.read_workflow_history(contract_address, num_results)

opengradient/alphasense/read_workflow_tool.py

@@ -64,7 +64,7 @@ def create_read_workflow_tool(
 
     # define runnable
     def read_workflow():
-        output = og.read_workflow_result(contract_address=workflow_contract_address)
+        output = og.alpha.read_workflow_result(contract_address=workflow_contract_address)
         return output_formatter(output)
 
     if tool_type == ToolType.LANGCHAIN:

opengradient/client.py

@@ -48,7 +48,7 @@ from .defaults import (
     DEFAULT_OPENGRADIENT_LLM_STREAMING_SERVER_URL,
     DEFAULT_NETWORK_FILTER,
 )
-from .utils import convert_array_to_model_output, convert_to_model_input, convert_to_model_output
+from .utils import convert_to_model_input, convert_to_model_output
 
 _FIREBASE_CONFIG = {
     "apiKey": "AIzaSyDUVckVtfl-hiteBzPopy1pDD8Uvfncs7w",
@@ -153,6 +153,25 @@ class Client:
         if google_api_key or os.getenv("GOOGLE_API_KEY"):
             self._external_api_keys["google"] = google_api_key or os.getenv("GOOGLE_API_KEY")
 
+        self._alpha = None  # Lazy initialization for alpha namespace
+
+    @property
+    def alpha(self):
+        """
+        Access Alpha Testnet features.
+
+        Returns:
+            Alpha: Alpha namespace with workflow and ML model execution methods.
+
+        Example:
+            client = og.new_client(...)
+            result = client.alpha.new_workflow(model_cid, input_query, input_tensor_name)
+        """
+        if self._alpha is None:
+            from .alpha import Alpha
+            self._alpha = Alpha(self)
+        return self._alpha
+
     def set_api_key(self, provider: str, api_key: str):
         """
         Set or update API key for an external provider.
@@ -1425,216 +1444,6 @@ class Client:
 
         return tx_hash, tx_receipt
 
-    def new_workflow(
-        self,
-        model_cid: str,
-        input_query: HistoricalInputQuery,
-        input_tensor_name: str,
-        scheduler_params: Optional[SchedulerParams] = None,
-    ) -> str:
-        """
-        Deploy a new workflow contract with the specified parameters.
-
-        This function deploys a new workflow contract on OpenGradient that connects
-        an AI model with its required input data. When executed, the workflow will fetch
-        the specified model, evaluate the input query to get data, and perform inference.
-
-        The workflow can be set to execute manually or automatically via a scheduler.
-
-        Args:
-            model_cid (str): CID of the model to be executed from the Model Hub
-            input_query (HistoricalInputQuery): Input definition for the model inference,
-                will be evaluated at runtime for each inference
-            input_tensor_name (str): Name of the input tensor expected by the model
-            scheduler_params (Optional[SchedulerParams]): Scheduler configuration for automated execution:
-                - frequency: Execution frequency in seconds
-                - duration_hours: How long the schedule should live for
-
-        Returns:
-            str: Deployed contract address. If scheduler_params was provided, the workflow
-                 will be automatically executed according to the specified schedule.
-
-        Raises:
-            Exception: If transaction fails or gas estimation fails
-        """
-        # Get contract ABI and bytecode
-        abi = self._get_abi("PriceHistoryInference.abi")
-        bytecode = self._get_bin("PriceHistoryInference.bin")
-
-        def deploy_transaction():
-            contract = self._blockchain.eth.contract(abi=abi, bytecode=bytecode)
-            query_tuple = input_query.to_abi_format()
-            constructor_args = [model_cid, input_tensor_name, query_tuple]
-
-            try:
-                # Estimate gas needed
-                estimated_gas = contract.constructor(*constructor_args).estimate_gas({"from": self._wallet_account.address})
-                gas_limit = int(estimated_gas * 1.2)
-            except Exception as e:
-                print(f"⚠️ Gas estimation failed: {str(e)}")
-                gas_limit = 5000000  # Conservative fallback
-                print(f"📊 Using fallback gas limit: {gas_limit}")
-
-            transaction = contract.constructor(*constructor_args).build_transaction(
-                {
-                    "from": self._wallet_account.address,
-                    "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
-                    "gas": gas_limit,
-                    "gasPrice": self._blockchain.eth.gas_price,
-                    "chainId": self._blockchain.eth.chain_id,
-                }
-            )
-
-            signed_txn = self._wallet_account.sign_transaction(transaction)
-            tx_hash = self._blockchain.eth.send_raw_transaction(signed_txn.raw_transaction)
-
-            tx_receipt = self._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
-
-            if tx_receipt["status"] == 0:
-                raise Exception(f"❌ Contract deployment failed, transaction hash: {tx_hash.hex()}")
-
-            return tx_receipt.contractAddress
-
-        contract_address = run_with_retry(deploy_transaction)
-
-        if scheduler_params:
-            self._register_with_scheduler(contract_address, scheduler_params)
-
-        return contract_address
-
-    def _register_with_scheduler(self, contract_address: str, scheduler_params: SchedulerParams) -> None:
-        """
-        Register the deployed workflow contract with the scheduler for automated execution.
-
-        Args:
-            contract_address (str): Address of the deployed workflow contract
-            scheduler_params (SchedulerParams): Scheduler configuration containing:
-                - frequency: Execution frequency in seconds
-                - duration_hours: How long to run in hours
-                - end_time: Unix timestamp when scheduling should end
-
-        Raises:
-            Exception: If registration with scheduler fails. The workflow contract will
-                      still be deployed and can be executed manually.
-        """
-
-        scheduler_abi = self._get_abi("WorkflowScheduler.abi")
-
-        # Scheduler contract address
-        scheduler_address = DEFAULT_SCHEDULER_ADDRESS
-        scheduler_contract = self._blockchain.eth.contract(address=scheduler_address, abi=scheduler_abi)
-
-        try:
-            # Register the workflow with the scheduler
-            scheduler_tx = scheduler_contract.functions.registerTask(
-                contract_address, scheduler_params.end_time, scheduler_params.frequency
-            ).build_transaction(
-                {
-                    "from": self._wallet_account.address,
-                    "gas": 300000,
-                    "gasPrice": self._blockchain.eth.gas_price,
-                    "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
-                    "chainId": self._blockchain.eth.chain_id,
-                }
-            )
-
-            signed_scheduler_tx = self._wallet_account.sign_transaction(scheduler_tx)
-            scheduler_tx_hash = self._blockchain.eth.send_raw_transaction(signed_scheduler_tx.raw_transaction)
-            self._blockchain.eth.wait_for_transaction_receipt(scheduler_tx_hash, timeout=REGULAR_TX_TIMEOUT)
-        except Exception as e:
-            print(f"❌ Error registering contract with scheduler: {str(e)}")
-            print("  The workflow contract is still deployed and can be executed manually.")
-
-    def read_workflow_result(self, contract_address: str) -> ModelOutput:
-        """
-        Reads the latest inference result from a deployed workflow contract.
-
-        Args:
-            contract_address (str): Address of the deployed workflow contract
-
-        Returns:
-            ModelOutput: The inference result from the contract
-
-        Raises:
-            ContractLogicError: If the transaction fails
-            Web3Error: If there are issues with the web3 connection or contract interaction
-        """
-        # Get the contract interface
-        contract = self._blockchain.eth.contract(
-            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
-        )
-
-        # Get the result
-        result = contract.functions.getInferenceResult().call()
-
-        return convert_array_to_model_output(result)
-
-    def run_workflow(self, contract_address: str) -> ModelOutput:
-        """
-        Triggers the run() function on a deployed workflow contract and returns the result.
-
-        Args:
-            contract_address (str): Address of the deployed workflow contract
-
-        Returns:
-            ModelOutput: The inference result from the contract
-
-        Raises:
-            ContractLogicError: If the transaction fails
-            Web3Error: If there are issues with the web3 connection or contract interaction
-        """
-        # Get the contract interface
-        contract = self._blockchain.eth.contract(
-            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
-        )
-
-        # Call run() function
-        nonce = self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending")
-
-        run_function = contract.functions.run()
-        transaction = run_function.build_transaction(
-            {
-                "from": self._wallet_account.address,
-                "nonce": nonce,
-                "gas": 30000000,
-                "gasPrice": self._blockchain.eth.gas_price,
-                "chainId": self._blockchain.eth.chain_id,
-            }
-        )
-
-        signed_txn = self._wallet_account.sign_transaction(transaction)
-        tx_hash = self._blockchain.eth.send_raw_transaction(signed_txn.raw_transaction)
-        tx_receipt = self._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=INFERENCE_TX_TIMEOUT)
-
-        if tx_receipt.status == 0:
-            raise ContractLogicError(f"Run transaction failed. Receipt: {tx_receipt}")
-
-        # Get the inference result from the contract
-        result = contract.functions.getInferenceResult().call()
-
-        return convert_array_to_model_output(result)
-
-    def read_workflow_history(self, contract_address: str, num_results: int) -> List[ModelOutput]:
-        """
-        Gets historical inference results from a workflow contract.
-
-        Retrieves the specified number of most recent inference results from the contract's
-        storage, with the most recent result first.
-
-        Args:
-            contract_address (str): Address of the deployed workflow contract
-            num_results (int): Number of historical results to retrieve
-
-        Returns:
-            List[ModelOutput]: List of historical inference results
-        """
-        contract = self._blockchain.eth.contract(
-            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
-        )
-
-        results = contract.functions.getLastInferenceResults(num_results).call()
-        return [convert_array_to_model_output(result) for result in results]
-
     def _get_inference_result_from_node(self, inference_id: str, inference_mode: InferenceMode) -> Dict:
         """
         Get the inference result from node.

opengradient/defaults.py

@@ -1,5 +1,5 @@
 # Default variables
-DEFAULT_RPC_URL = "https://eth-devnet.opengradient.ai"
+DEFAULT_RPC_URL = "https://ogevmdevnet.opengradient.ai"
 DEFAULT_API_URL = "https://sdk-devnet.opengradient.ai"
 DEFAULT_OG_FAUCET_URL = "https://faucet.opengradient.ai/?address="
 DEFAULT_HUB_SIGNUP_URL = "https://hub.opengradient.ai/signup"

opengradient/workflow_models/utils.py

@@ -26,7 +26,7 @@ def read_workflow_wrapper(contract_address: str, format_function: Callable[...,
         format_function (Callable): Function for formatting the result returned by read_workflow
     """
     try:
-        result = og.read_workflow_result(contract_address)
+        result = og.alpha.read_workflow_result(contract_address)
 
         formatted_result = format_function(result)
         block_explorer_link = create_block_explorer_link_smart_contract(contract_address)

opengradient/x402_auth.py

@@ -1,60 +1,102 @@
-import httpx
-import typing
-import logging
+"""
+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, PaymentRequirements
+from x402.types import x402PaymentRequiredResponse
 
 
 class X402Auth(httpx.Auth):
-    """Auth class for handling x402 payment requirements."""
+    """
+    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,
+        account: LocalAccount,
+        max_value: Optional[int] = None,
+        network_filter: Optional[str] = None,
+        scheme_filter: Optional[str] = None,
     ):
-        self.x402_client = x402Client(
+        """
+        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,
-            payment_requirements_selector=payment_requirements_selector,  # type: ignore
+            network_filter=network_filter,
+            scheme_filter=scheme_filter,
         )
 
-    async def async_auth_flow(
+    def auth_flow(
         self, request: httpx.Request
-    ) -> typing.AsyncGenerator[httpx.Request, httpx.Response]:
+    ) -> 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 response.status_code == 402:
-            try:
-                await response.aread()
-                data = response.json()
+        # 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)
 
-                payment_response = x402PaymentRequiredResponse(**data)
+            # Select payment requirements
+            selected_requirements = self._x402_client.select_payment_requirements(
+                payment_response.accepts
+            )
 
-                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
+            )
 
-                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"
 
-                request.headers["X-Payment"] = payment_header
-                request.headers["Access-Control-Expose-Headers"] = "X-Payment-Response"
-                yield request
+            yield request
 
-            except Exception as e:
-                logging.error(f"X402Auth: Error handling payment: {e}")
-                return
+        except Exception:
+            # If payment handling fails, just return the original 402 response
+            return

{opengradient-0.5.9.dist-info → opengradient-0.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opengradient
-Version: 0.5.9
+Version: 0.5.10
 Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <kyle@vannalabs.ai>
 License-Expression: MIT
@@ -35,6 +35,7 @@ A Python SDK for decentralized model management and inference services on the Op
 - Model management and versioning
 - Decentralized model inference
 - Support for LLM inference with various models
+- **Trusted Execution Environment (TEE) inference** with cryptographic attestation
 - End-to-end verified AI execution
 - Command-line interface (CLI) for direct access
 
@@ -46,7 +47,6 @@ Browse and discover AI models on our [Model Hub](https://hub.opengradient.ai/).
 - Direct integration with the SDK
 
 ## Installation
-
 ```bash
 pip install opengradient
 ```
@@ -62,7 +62,6 @@ You'll need two accounts to use the SDK:
 - **OpenGradient account**: Use an existing Ethereum-compatible wallet or create a new one via SDK
 
 The easiest way to set up your accounts is through our configuration wizard:
-
 ```bash
 opengradient config init
 ```
@@ -73,7 +72,6 @@ This wizard will:
 - Direct you to our Test Faucet for devnet tokens
 
 ### 2. Initialize the SDK
-
 ```python
 import opengradient as og
 og.init(private_key="<private_key>", email="<email>", password="<password>")
@@ -82,8 +80,6 @@ og.init(private_key="<private_key>", email="<email>", password="<password>")
 ### 3. Basic Usage
 
 Browse available models on our [Model Hub](https://hub.opengradient.ai/) or create and upload your own:
-
-
 ```python
 # Create and upload a model
 og.create_model(
@@ -101,20 +97,41 @@ result = og.infer(
 )
 ```
 
-### 4. Examples
+### 4. TEE (Trusted Execution Environment) Inference
+
+OpenGradient supports secure, verifiable inference through TEE for leading LLM providers. Access models from OpenAI, Anthropic, Google, and xAI with cryptographic attestation:
+```python
+from opengradient import TEE_LLM
+
+# Use TEE-enabled models for verifiable AI execution
+result = og.infer(
+    model_cid=TEE_LLM.CLAUDE_3_7_SONNET,  # or any other TEE_LLM model
+    model_inputs={"prompt": "Your prompt here"},
+    inference_mode=og.InferenceMode.TEE
+)
+```
+
+**Available TEE Models:**
+The SDK includes models from multiple providers accessible via the `TEE_LLM` enum:
+- **OpenAI**: GPT-4.1, GPT-4o, o4-mini
+- **Anthropic**: Claude 3.7 Sonnet, Claude 3.5 Haiku, Claude 4.0 Sonnet
+- **Google**: Gemini 2.5 Flash, Gemini 2.5 Pro, and more
+- **xAI**: Grok 3 Beta, Grok 4.1 Fast, and other Grok variants
+
+For the complete list of available models, check the `TEE_LLM` enum in your IDE autocomplete or see the [API documentation](https://docs.opengradient.ai/).
+
+### 5. Examples
 
 See code examples under [examples](./examples).
 
 ## CLI Usage
 
 The SDK includes a command-line interface for quick operations. First, verify your configuration:
-
 ```bash
 opengradient config show
 ```
 
 Run a test inference:
-
 ```bash
 opengradient infer -m QmbUqS93oc4JTLMHwpVxsE39mhNxy6hpf6Py3r9oANr8aZ \
     --input '{"num_input1":[1.0, 2.0, 3.0], "num_input2":10}'
@@ -124,7 +141,9 @@ opengradient infer -m QmbUqS93oc4JTLMHwpVxsE39mhNxy6hpf6Py3r9oANr8aZ \
 
 1. **Off-chain Applications**: Use OpenGradient as a decentralized alternative to centralized AI providers like HuggingFace and OpenAI.
 
-2. **Model Development**: Manage models on the Model Hub and integrate directly into your development workflow.
+2. **Verifiable AI Execution**: Leverage TEE inference for cryptographically attested AI outputs, enabling trustless AI applications.
+
+3. **Model Development**: Manage models on the Model Hub and integrate directly into your development workflow.
 
 ## Documentation
 
@@ -140,4 +159,4 @@ If you use [Claude Code](https://claude.ai/code), copy [docs/CLAUDE_SDK_USERS.md
 
 - Run `opengradient --help` for CLI command reference
 - Visit our [documentation](https://docs.opengradient.ai/) for detailed guides
-- Join our [community](https://.opengradient.ai/) for support
+- Join our [community](https://opengradient.ai/) for support

{opengradient-0.5.9.dist-info → opengradient-0.5.10.dist-info}/RECORD

@@ -1,18 +1,19 @@
-opengradient/__init__.py,sha256=1PSbDRGe4ft_0FYoPS3XpeajnRPOTkmx8aZZxcOeztQ,13455
+opengradient/__init__.py,sha256=hRGex2VGwAQ-lqBNphW93D4R3wPHQpQrTkwgGLe2MoA,10255
 opengradient/account.py,sha256=5wrYpws_1lozjOFjLCTHtxgoxK-LmObDAaVy9eDcJY4,1145
+opengradient/alpha.py,sha256=WAtL1GGbEpoeLO89rOMd8-YAgAFJYM1UJlICm6YGsPs,15195
 opengradient/cli.py,sha256=pfgyLfD1MIDifKmGLFsJqBlgvqIcnsIh3zzg7PaIeH4,33670
-opengradient/client.py,sha256=KDkFxcZ-vGyriFW-ydWTnitgV6rYfxtnNzchWca-8u8,74009
-opengradient/defaults.py,sha256=YOtFDq8HiwEkgMXlV4Zf3YgkopfKUkkx0CpgNuY_Mxk,796
+opengradient/client.py,sha256=B13xv_iL2ZynCsiojfsXuERzIdbt62UoOLd_s_moCnA,65250
+opengradient/defaults.py,sha256=8faLPwvp_BQdErY_SEjBzvmGVuOBdZ2zKcoryD8SCXk,797
 opengradient/exceptions.py,sha256=88tfegboGtlehQcwhxsl6ZzhLJWZWlkf_bkHTiCtXpo,3391
 opengradient/types.py,sha256=bADakUM6WwdMORGC5HvQvWCezNwIlVc7l0zodPapbhQ,14622
 opengradient/utils.py,sha256=ZUq4OBIml2vsC0tRqus4Zwb_e3g4woo00apByrafuVw,8058
-opengradient/x402_auth.py,sha256=Jmj-40OybugOXIt_qHzN1qy4x7U3QuM1MKNmPzoEKwc,1920
+opengradient/x402_auth.py,sha256=utfusvfKxPtsq4MtRX03yQ969G7VeatxAQwHLAW77JU,3350
 opengradient/abi/InferencePrecompile.abi,sha256=reepTHg6Q01UrFP0Gexc-JayplsvOLPfG7jrEZ-cV28,10197
 opengradient/abi/PriceHistoryInference.abi,sha256=ZB3fZdx1kaFlp2wt1vTbTZZG1k8HPvmNtkG5Q8Bnajw,5098
 opengradient/abi/WorkflowScheduler.abi,sha256=yEGs76qO4S1z980KL5hBdfyXiJ6k-kERcB1O_o73AEU,416
 opengradient/abi/inference.abi,sha256=MR5u9npZ-Yx2EqRW17_M-UnGgFF3mMEMepOwaZ-Bkgc,7040
 opengradient/alphasense/__init__.py,sha256=Ah6IpoPTb6UkY7ImOWLJs3tjlxDJx6vZVR7p5IwP_Ks,292
-opengradient/alphasense/read_workflow_tool.py,sha256=ojCf-eMO6e0ib77nqjgEJtXxTxdLZmc_-MvyRemYFY0,3216
+opengradient/alphasense/read_workflow_tool.py,sha256=Y_MKRpBR1dNvCu9gNxcSnT3E_IqxZUAkE-_XziJ0BVY,3222
 opengradient/alphasense/run_model_tool.py,sha256=wlDqXVHa1xpqQy_hmht_wWegxtqdYgYBXNbRP3qbfwM,6945
 opengradient/alphasense/types.py,sha256=uxk4JQKbaS2cM3ZiKpdHQb234OJ5ylprNR5vi01QFzA,220
 opengradient/bin/PriceHistoryInference.bin,sha256=nU2FZpGHIKBZ7NSK9Sr-p9lr-nXja_40ISPN9yckDq8,41276
@@ -26,11 +27,11 @@ opengradient/proto/infer_pb2_grpc.py,sha256=q42_eZ7OZCMTXdWocYA4Ka3B0c3B74dOhfqd
 opengradient/workflow_models/__init__.py,sha256=pAGRaMZOXmuPnqG5gAQB1FeFLYxQ4F4bmYdrqXIez7c,826
 opengradient/workflow_models/constants.py,sha256=viIkb_LGcfVprqQNaA80gBTj6cfYam0r6b6MHW9XGFA,740
 opengradient/workflow_models/types.py,sha256=Z22hF6c8Y4D2GlzVEIBODGwsqSjSrQvUcpZ7R-mIJdI,409
-opengradient/workflow_models/utils.py,sha256=ySfpuiOBqLTlfto6ZxZf2vc7K6RGIja0l4eaVm5AOzY,1503
+opengradient/workflow_models/utils.py,sha256=aL2-Hp5J5qlJft6-wx4GnZNOXZ1vjYaTF1uEgYavWdI,1509
 opengradient/workflow_models/workflow_models.py,sha256=d4C_gs39DAfy4cdY9Ee6GMXpPfzwvKFpmxzK1A7LNgU,3900
-opengradient-0.5.9.dist-info/licenses/LICENSE,sha256=xEcvQ3AxZOtDkrqkys2Mm6Y9diEnaSeQRKvxi-JGnNA,1069
-opengradient-0.5.9.dist-info/METADATA,sha256=kSTyBctZ-r4h3ilq7DRgxvxQhYO4ejUl3KbwcDX1Ygs,4215
-opengradient-0.5.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-opengradient-0.5.9.dist-info/entry_points.txt,sha256=yUKTaJx8RXnybkob0J62wVBiCp_1agVbgw9uzsmaeJc,54
-opengradient-0.5.9.dist-info/top_level.txt,sha256=oC1zimVLa2Yi1LQz8c7x-0IQm92milb5ax8gHBHwDqU,13
-opengradient-0.5.9.dist-info/RECORD,,
+opengradient-0.5.10.dist-info/licenses/LICENSE,sha256=xEcvQ3AxZOtDkrqkys2Mm6Y9diEnaSeQRKvxi-JGnNA,1069
+opengradient-0.5.10.dist-info/METADATA,sha256=Pfj4IQ8soL-1AO5X5PbqcunZF4K0UK3AixX3Lfsh_Bw,5437
+opengradient-0.5.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+opengradient-0.5.10.dist-info/entry_points.txt,sha256=yUKTaJx8RXnybkob0J62wVBiCp_1agVbgw9uzsmaeJc,54
+opengradient-0.5.10.dist-info/top_level.txt,sha256=oC1zimVLa2Yi1LQz8c7x-0IQm92milb5ax8gHBHwDqU,13
+opengradient-0.5.10.dist-info/RECORD,,