ogpu 0.2.0.0__py3-none-any.whl

ogpu/client/config.py

@@ -0,0 +1,18 @@
+import json
+import os
+
+from dotenv import load_dotenv
+from web3 import Web3
+
+load_dotenv()
+
+WEB3_RPC_URL = os.getenv("WEB3_RPC_URL")
+if not WEB3_RPC_URL:
+    raise ValueError("`WEB3_RPC_URL` environment variable is not set.")
+
+CLIENT_PRIVATE_KEY = os.getenv("CLIENT_PRIVATE_KEY")
+
+# Web3 instance
+WEB3 = Web3(Web3.HTTPProvider(WEB3_RPC_URL))
+if not WEB3.is_connected():
+    raise ConnectionError("Failed to connect to the node at the provided RPC URL.")

ogpu/client/contracts.py

@@ -0,0 +1,18 @@
+import json
+
+from .utils import load_contract
+
+with open("abis/NexusAbi.json") as f:
+    NEXUS_ABI = json.load(f)
+with open("abis/ControllerAbi.json") as f:
+    CONTROLLER_ABI = json.load(f)
+
+NEXUS_CONTRACT_ADDRESS = "0x731329542F2dABC433f84BF0498791999D03FfBE"
+CONTROLLER_CONTRACT_ADDRESS = "0xeb45d738E8c59BFa30bf6109340ccbb41469eedA"
+
+
+NexusContract = load_contract(NEXUS_CONTRACT_ADDRESS, NEXUS_ABI)
+ControllerContract = load_contract(CONTROLLER_CONTRACT_ADDRESS, CONTROLLER_ABI)
+
+# Export the contracts for easy access
+__all__ = ["NexusContract", "ControllerContract"]

ogpu/client/source.py

@@ -0,0 +1,33 @@
+from eth_account import Account
+from web3 import Web3
+
+from .config import CLIENT_PRIVATE_KEY
+from .contracts import *
+from .types import SourceParams
+
+
+def create_source(
+    web3: Web3,
+    source_params: SourceParams,
+    private_key: str | None = CLIENT_PRIVATE_KEY,
+) -> str:
+    acc = Account.from_key(private_key)
+
+    tx = NexusContract.functions.publishSource(
+        source_params.to_tuple()
+    ).build_transaction(
+        {
+            "from": acc.address,
+            "value": web3.to_wei(source_params.minPayment, "wei"),
+            "nonce": web3.eth.get_transaction_count(acc.address),
+            "gas": 8000000,
+            "gasPrice": web3.to_wei("10", "gwei"),
+        }
+    )
+
+    signed = web3.eth.account.sign_transaction(tx, private_key)
+    tx_hash = web3.eth.send_raw_transaction(signed.rawTransaction)
+    receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
+
+    logs = NexusContract.events.SourcePublished().process_receipt(receipt)
+    return logs[0]["args"]["source"]

ogpu/client/types.py

@@ -0,0 +1,46 @@
+import time
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class SourceParams(BaseModel):
+    clientAddress: str
+    imageMetadataUrl: str
+    imageEnvironments: bytes
+    minPayment: int
+    minAvailableLockup: int
+    maxExpiryTime: int
+    privacyEnabled: bool
+    optionalParamsUrl: str
+    deliveryMethod: int
+    lastUpdateTime: int = int(time.time())
+
+    def to_tuple(self):
+        return (
+            self.clientAddress,
+            self.imageMetadataUrl,
+            self.imageEnvironments,
+            self.minPayment,
+            self.minAvailableLockup,
+            self.maxExpiryTime,
+            self.privacyEnabled,
+            self.optionalParamsUrl,
+            self.deliveryMethod,
+            self.lastUpdateTime,
+        )
+
+
+class TaskParams(BaseModel):
+    source: str
+    config: str
+    expiryTime: int
+    payment: int
+
+    def to_tuple(self):
+        return (
+            self.source,
+            self.config,
+            self.expiryTime,
+            self.payment,
+        )

ogpu/client/utils.py

@@ -0,0 +1,9 @@
+from typing import Dict
+
+from web3 import Web3
+
+from .config import WEB3
+
+
+def load_contract(address: str, abi: Dict):
+    return WEB3.eth.contract(address=Web3.to_checksum_address(address), abi=abi)

ogpu/service/__init__.py

@@ -0,0 +1,7 @@
+"""
+Basic imports for registering, serving, and logging user-defined functions.
+"""
+
+from .decorators import expose  # Function registration decorator
+from .logger import logger  # Logging interface
+from .server import start  # Server launcher

ogpu/service/config.py

@@ -0,0 +1,8 @@
+import os
+
+SENTRY_DSN = os.getenv("OGPU_SERVICE_SENTRY_DSN")
+
+SOURCE_ADDRESS = os.getenv("SOURCE_ADDRESS", "0xundefined")
+
+SERVICE_HOST = "0.0.0.0"
+SERVICE_PORT = 5555

ogpu/service/decorators.py

@@ -0,0 +1,94 @@
+import inspect
+import threading
+from functools import wraps
+from typing import get_type_hints
+
+from pydantic import BaseModel
+
+from .handler import add_handler, get_handlers
+from .logger import logger
+
+
+def expose(timeout: int | None = None):
+    """
+    Decorator to expose user functions as handlers for OpenGPU service.
+    The function's input and output must be Pydantic BaseModel.
+    An optional timeout can be set for background execution.
+
+    Args:
+        timeout (int, optional): Timeout duration in seconds. If set, the handler will return None if not completed within this time.
+    """
+
+    def decorator(func):
+        function_name = func.__name__
+        # Check for unique handler names
+        existing_names = [f.__name__ for f, _, _ in get_handlers()]
+        if function_name in existing_names:
+            raise ValueError(
+                f"A handler named `{function_name}` is already registered."
+            )
+
+        sig = inspect.signature(func)
+        parameters = list(sig.parameters.values())
+        if len(parameters) != 1:
+            raise TypeError(
+                f"Function `{function_name}` must take exactly ONE input argument (got {len(parameters)})"
+            )
+
+        hints = get_type_hints(func)
+        if "return" not in hints:
+            raise TypeError(f"Function `{function_name}` must have a return type.")
+
+        input_model = hints[parameters[0].name]
+        output_model = hints["return"]
+
+        # Check if input and output types are subclasses of Pydantic BaseModel
+        if not (inspect.isclass(input_model) and issubclass(input_model, BaseModel)):
+            raise TypeError(
+                f"Input to `{function_name}` must be a subclass of pydantic.BaseModel"
+            )
+
+        if not (inspect.isclass(output_model) and issubclass(output_model, BaseModel)):
+            raise TypeError(
+                f"Return type of `{function_name}` must be a subclass of pydantic.BaseModel"
+            )
+
+        if timeout:
+
+            @wraps(func)
+            def timed_handler(data):
+                """
+                Handler that runs with a timeout. Returns None if not completed in time.
+                """
+                result = [None]
+                done = threading.Event()
+
+                def run():
+                    try:
+                        result[0] = func(data)
+                    except Exception as e:
+                        logger.task_fail(f"Exception in `{function_name}`: {e}")  # type: ignore
+                    finally:
+                        done.set()
+
+                thread = threading.Thread(target=run)
+                thread.start()
+                finished = done.wait(timeout)
+
+                if not finished:
+                    logger.task_timeout(  # type: ignore
+                        f"`{function_name}` timed out after {timeout} seconds"
+                    )
+                    # Do not wait for the result, just return None immediately
+                    return None
+
+                return result[0]
+
+            add_handler(timed_handler, input_model, output_model)
+            return func
+
+        # If no timeout, add handler directly
+        add_handler(func, input_model, output_model)
+        return func
+
+    return decorator

ogpu/service/handler.py

@@ -0,0 +1,31 @@
+from typing import Callable, List, Tuple, Type
+
+from pydantic import BaseModel
+
+# List of registered handler functions: (function, input model, output model)
+_exposed_handlers: List[Tuple[Callable, Type[BaseModel], Type[BaseModel]]] = []
+
+
+def add_handler(
+    fn: Callable, input_model: Type[BaseModel], output_model: Type[BaseModel]
+):
+    """
+    Registers a new handler function with its input and output models.
+
+    Args:
+        fn (Callable): The handler function to register.
+        input_model (Type[BaseModel]): The Pydantic model for input validation.
+        output_model (Type[BaseModel]): The Pydantic model for output validation.
+    """
+    _exposed_handlers.append((fn, input_model, output_model))
+
+
+def get_handlers():
+    """
+    Returns all registered handler functions.
+
+    Returns:
+        List[Tuple[Callable, Type[BaseModel], Type[BaseModel]]]:
+            A list of tuples containing the handler function, input model, and output model.
+    """
+    return _exposed_handlers

ogpu/service/logger.py

@@ -0,0 +1,102 @@
+import logging
+import os
+
+import sentry_sdk
+from colorama import Fore, Style, init
+
+from . import config
+
+init(autoreset=True)
+
+logger = logging.getLogger("ogpu")
+
+
+if not logger.hasHandlers():
+    handler = logging.StreamHandler()
+
+    class PartyFormatter(logging.Formatter):
+        """
+        Custom formatter that colors log messages by level.
+        """
+
+        def format(self, record):
+            themes = {
+                "DEBUG": (Fore.BLUE, "DEBUG"),
+                "INFO": (Fore.GREEN, "INFO "),
+                "SUCCESS": (Fore.CYAN, "✅ SUCCESS"),
+                "WARNING": (Fore.YELLOW, "WARNING"),
+                "ERROR": (Fore.RED, "ERROR"),
+                "FAIL": (Fore.RED, "❌ FAIL"),
+                "TIMEOUT": (Fore.LIGHTMAGENTA_EX, "⏱️  TIMEOUT"),
+                "CRITICAL": (Fore.MAGENTA, "CRITICAL"),
+            }
+            color, label = themes.get(record.levelname, ("", record.levelname))
+            record.levelname = f"{color}{label}{Style.RESET_ALL}"
+            return super().format(record)
+
+    formatter = PartyFormatter(
+        fmt="[{asctime}] {levelname:<20} {message}",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        style="{",
+    )
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+logger.setLevel(logging.INFO)
+
+# Define custom log levels
+SUCCESS_LEVEL = 25
+TIMEOUT_LEVEL = 35
+FAIL_LEVEL = 45
+
+logging.addLevelName(SUCCESS_LEVEL, "SUCCESS")
+logging.addLevelName(FAIL_LEVEL, "FAIL")
+logging.addLevelName(TIMEOUT_LEVEL, "TIMEOUT")
+
+
+def task_success(self, message, *args, **kwargs):
+    """Custom log level for successful operations."""
+    if self.isEnabledFor(SUCCESS_LEVEL):
+        self._log(SUCCESS_LEVEL, message, args, **kwargs)
+
+
+def task_fail(self, message, *args, **kwargs):
+    """Custom log level for failed operations."""
+    if self.isEnabledFor(FAIL_LEVEL):
+        self._log(FAIL_LEVEL, message, args, **kwargs)
+        if config.SENTRY_DSN:
+            try:
+                sentry_sdk.capture_message(str(message), level="error")
+            except Exception:
+                pass
+
+
+def task_timeout(self, message, *args, **kwargs):
+    """Custom log level for timeout situations."""
+    if self.isEnabledFor(TIMEOUT_LEVEL):
+        self._log(TIMEOUT_LEVEL, message, args, **kwargs)
+        if config.SENTRY_DSN:
+            try:
+                sentry_sdk.capture_message(str(message), level="warning")
+            except Exception:
+                pass
+
+
+# Add custom levels to Logger
+setattr(logging.Logger, "task_success", task_success)
+setattr(logging.Logger, "task_fail", task_fail)
+setattr(logging.Logger, "task_timeout", task_timeout)
+
+
+if config.SENTRY_DSN:
+    sentry_sdk.init(
+        dsn=config.SENTRY_DSN,
+        traces_sample_rate=0.1,
+        environment=os.getenv("OGPU_SERVICE_ENV", "production"),
+        release="0.0.1",
+    )
+
+    with sentry_sdk.configure_scope() as scope:
+        scope.set_tag("source_address", config.SOURCE_ADDRESS)
+
+    logger.info("Sentry logging enabled.")

ogpu/service/server.py

@@ -0,0 +1,62 @@
+import uvicorn
+from fastapi import BackgroundTasks, FastAPI
+
+from .config import SERVICE_HOST, SERVICE_PORT
+from .handler import get_handlers
+from .logger import logger
+
+
+def start():
+    """
+    Serves registered handler functions as HTTP endpoints using FastAPI.
+    Creates a /run/{function}/{task_address} endpoint for each handler.
+    """
+    logger.info("Starting OpenGPU Service server...")
+    app = FastAPI(title="OpenGPU Service", version="0.1.0")
+
+    def create_endpoint(handler, input_model, function_name):
+        """
+        Dynamically generates an endpoint function for each handler.
+        """
+
+        async def endpoint(
+            task_address: str, data: input_model, background_tasks: BackgroundTasks  # type: ignore
+        ):
+            """
+            Runs the handler in the background when an HTTP request is received.
+            """
+
+            def runner():
+                try:
+                    result = handler(data)
+                    if result:
+                        logger.task_success(  # type: ignore
+                            f"[{task_address}] Function: `{function_name}`, Result → "
+                            + ", ".join(
+                                [f"{k}={v}" for k, v in result.model_dump().items()]
+                            )
+                        )
+                except Exception as e:
+                    logger.task_fail(  # type: ignore
+                        f"[{task_address}] Error in `{function_name}`: {e}"
+                    )
+
+            background_tasks.add_task(runner)
+            return {"task_address": task_address, "status": "accepted"}
+
+        return endpoint
+
+    # Create endpoints for all registered handlers
+    for handler, input_model, _output_model in get_handlers():
+        function_name = handler.__name__
+        path = f"/run/{function_name}/{{task_address}}"
+
+        endpoint = create_endpoint(handler, input_model, function_name)
+        app.post(path, status_code=202)(endpoint)
+        logger.info(f"Registered endpoint → /run/{function_name}/{{task_address}}")
+
+    logger.info("Connected to OpenGPU Service 🔵")
+    logger.info("Listening on http://0.0.0.0:5555")
+
+    # Start FastAPI server
+    uvicorn.run(app, host=SERVICE_HOST, port=SERVICE_PORT, log_level="warning")

ogpu-0.2.0.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: ogpu
+Version: 0.2.0.0
+Summary: OpenGPU SDK for distributed AI task deployment
+Author-email: Kutay <kutay@opengpu.network>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: colorama==0.4.6
+Requires-Dist: fastapi==0.115.12
+Requires-Dist: pydantic==2.11.4
+Requires-Dist: uvicorn==0.34.2
+Requires-Dist: sentry_sdk==2.29.1
+Requires-Dist: python-dotenv==1.1.0
+Requires-Dist: web3==7.12.0
+
+# 🧠 OpenGPU SDK
+
+Welcome to the edge of distributed AI.
+
+The `ogpu.service` SDK lets you write **task handlers** that will run **on remote provider machines** — not your laptop.  
+You define what your task expects and yapar, and we handle the wiring, serving, and background magic.
+
+> ✨ Write your task. 🛰️ Deploy it. ⚡️ Let the network run it.
+
+---
+
+## 🚀 What is this?
+
+This SDK is used by **client developers** to write Python **tasks** (as functions) that will be deployed and executed **on OpenGPU network providers**.
+
+Your code will:
+- Accept inputs (Pydantic model)
+- Process them inside a registered **task handler**
+- Expose a `/run/{task}/{task_address}` endpoint via FastAPI
+- Be served by remote compute
+
+---
+
+## 🧪 Example: Your First Task
+
+```python
+import ogpu.service
+from pydantic import BaseModel
+
+class MultiplyInput(BaseModel):
+    a: int
+    b: int
+
+class MultiplyOutput(BaseModel):
+    result: int
+
+@ogpu.service.expose()
+def multiply(data: MultiplyInput) -> MultiplyOutput:
+    ogpu.service.logger.info(f"🧮 Starting multiplication: {data.a} * {data.b}")
+    result = data.a * data.b
+    ogpu.service.logger.info(f"✅ Result computed: {result}")
+    return MultiplyOutput(result=result)
+
+ogpu.service.start()
+```
+
+That’s it.
+This exposes an endpoint at:
+
+```
+POST /run/multiply/{task_address}
+```
+
+With body:
+```json
+{
+  "a": 5,
+  "b": 7
+}
+```
+
+---
+
+## 📡 How It Works
+
+- `@expose()`: Marks your function as a **task handler**.
+- `start()`: Starts a FastAPI server that awaits tasks.
+- Your task runs in a background thread.
+- The result is logged, not returned over HTTP.
+
+---
+
+## 🧙 Guidelines
+
+- Your task handler must accept **one** `pydantic.BaseModel` input
+- It must return another `pydantic.BaseModel`
+- Task (function) names must be **unique**
+- Output will be logged to the console — keep it clean 💅
+
+---
+
+## 🤝 Made for the OpenGPU Network  
+Unleash your code. Let the grid handle the rest.

ogpu-0.2.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+ogpu/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ogpu/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ogpu/client/config.py,sha256=-sn8O25kGG6RGrd2nDdFIWcY9v54ev4ZZ4RnN2cpJrs,454
+ogpu/client/contracts.py,sha256=KaMIOmQs9P4oFw12ZI8HHvcVLkPx5LMgnkpcvld8KZE,574
+ogpu/client/source.py,sha256=wFHIyBIkN9QKL6FLVoyk80dKIZt01O12PcVRx8s1RZQ,1005
+ogpu/client/types.py,sha256=zsin96RoM1JG-ILjhQem95vbtgz9f-dNJHL8n4FjDZA,1013
+ogpu/client/utils.py,sha256=a8WBolSyeEYxl-ReybApyuo4CpzMshm2jrnu_sbdsvM,200
+ogpu/service/__init__.py,sha256=7hRMGk5cxwffLxoUpZHoGIRVCrS3EaEZClTLmetB_H8,244
+ogpu/service/config.py,sha256=3wDxVXDmiMcCYi8o5yxunTYuIpVSWMhnJwNCu7t72dI,168
+ogpu/service/decorators.py,sha256=d3daBHQIOb4FxwJo2xwTwz8q-IAuuMfxeSarZV61oeU,3268
+ogpu/service/handler.py,sha256=niqnTKRbYhVB5l-UbjNUh_lXggUXAmuuRySwlnO0jSc,1002
+ogpu/service/logger.py,sha256=Tjr9r9Y_l61v5t--A4mVAyFIZ-dlfLZbvH-DkQa-bTA,2997
+ogpu/service/server.py,sha256=jtKP8FPPtlbgggUikhVcOxu4bwh18_sxCFDhQOrgll0,2292
+ogpu-0.2.0.0.dist-info/METADATA,sha256=EV7rBuwmE27UaxflWADQOaYRkGKfqghylhhKDWABlR8,2560
+ogpu-0.2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ogpu-0.2.0.0.dist-info/top_level.txt,sha256=LhvIzChTfyKc02C9U5fM9Uo2-EIo2oSk4kRn8JCwn9M,5
+ogpu-0.2.0.0.dist-info/RECORD,,

ogpu-0.2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ogpu-0.2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ogpu