runpod 2.1.0__tar.gz → 2.2.0__tar.gz

{runpod-2.1.0 → runpod-2.2.0}/CHANGELOG.md

@@ -5,6 +5,13 @@
 ### Features
 
 * Apps expose `NetworkVolume` and `GlobalVolume` resources with explicit path-keyed mounts, lazy create-if-missing provisioning, and execution-bound filesystem access. Global volumes use GraphQL for lookup and creation.
+* Deployed Flash calls use endpoint or pod runtime credentials. Release requires deployed support from [RunPod#6686](https://github.com/runpod/RunPod/pull/6686), [ai-api#1176](https://github.com/runpod/ai-api/pull/1176), and [sdk-runtime#4](https://github.com/runpod-workers/sdk-runtime/pull/4).
+
+### Breaking Changes
+
+* Production endpoint environment variables reserve `RUNPOD_API_KEY` and runtime identity fields. Workers authenticate Flash calls with platform-issued runtime credentials; application credentials must use non-reserved environment names.
+* Deployed workers can invoke Flash resources only within their own app and environment, including through `Queue`, `Api`, and `Task` stubs. Local clients use account credentials subject to their permissions.
+* Remote queues, tasks, and JSON API calls require finite JSON-compatible arguments and results in local, dev, and deployed execution. Dev workers receive source separately from the JSON argument contract. Explicit `.local()` calls run Python directly.
 
 ### Bug Fixes
 
@@ -15,6 +22,26 @@
 * Deployment artifacts apply project ignore rules and mandatory secret-file exclusions while preserving vendored dependency assets.
 * Synchronous calls wait across polling timeouts on Python 3.10 and propagate operation timeouts.
 
+## [2.2.0](https://github.com/runpod/runpod-python/compare/v2.1.0...v2.2.0) (2026-11-09)
+
+
+### Features
+
+* invoke deployed flash tasks with runtime credentials (SEC-375 CON-1833) ([#644](https://github.com/runpod/runpod-python/issues/644)) ([367f174](https://github.com/runpod/runpod-python/commit/367f174ef14cc7fcf909a3b26413c3f2d38cbd9b))
+* make console, proxy, and endpoint hosts configurable ([#684](https://github.com/runpod/runpod-python/issues/684)) ([b9583f7](https://github.com/runpod/runpod-python/commit/b9583f7c0a02e6c0cbb9598538393fc239d88852))
+* resumable network volume upload and download ([#655](https://github.com/runpod/runpod-python/issues/655)) ([a677ee9](https://github.com/runpod/runpod-python/commit/a677ee9f08f21da5a29cc126ed63032fc1063365))
+
+
+### Bug Fixes
+
+* **apps:** accept datacenter ids outside the built-in list ([#690](https://github.com/runpod/runpod-python/issues/690)) ([dbc251a](https://github.com/runpod/runpod-python/commit/dbc251ac8ba87ed4cc53f71010bc8c87dba1c77d))
+* **serverless:** stop taking jobs after a per-job refresh_worker (SLS-900) ([#663](https://github.com/runpod/runpod-python/issues/663)) ([8ca9d9b](https://github.com/runpod/runpod-python/commit/8ca9d9bcfdc0ad1792e899cdef49a4fd172fbb13))
+
+
+### Documentation
+
+* rename getting_Started.md to getting_started.md ([#697](https://github.com/runpod/runpod-python/issues/697)) ([fbcabcd](https://github.com/runpod/runpod-python/commit/fbcabcd73889783d8e03b6261154891f13b0d9d6))
+
 ## [2.1.0](https://github.com/runpod/runpod-python/compare/v2.0.0...v2.1.0) (2026-11-03)
 
 

{runpod-2.1.0/runpod.egg-info → runpod-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runpod
-Version: 2.1.0
+Version: 2.2.0
 Summary: 🐍 | Python library for Runpod API and serverless worker SDK.
 Home-page: https://runpod.io
 Author: Runpod
@@ -34,7 +34,6 @@ Requires-Dist: backoff>=2.2.1
 Requires-Dist: boto3>=1.43.118
 Requires-Dist: certifi>=2026.10.19
 Requires-Dist: click>=8.5.0
-Requires-Dist: cloudpickle>=3.1.2
 Requires-Dist: colorama<0.4.7,>=0.4.6
 Requires-Dist: cryptography>=50.0.2
 Requires-Dist: fastapi[all]>=0.162.0
@@ -143,6 +142,18 @@ make setup
 make test
 ```
 
+## Remote values
+
+Queue and task calls use finite JSON-compatible arguments, return values,
+and stream chunks. JSON conversion turns tuples into lists and supported
+dictionary keys into strings, including in same-worker remote calls.
+Bytes, custom objects, circular references, and non-finite numbers produce
+explicit errors. `.local()` remains a direct Python call.
+
+Successful function responses contain `json_result`, including for a null
+return value. SDK and worker runtimes share the JSON protocol validators;
+use compatible package releases when building worker images.
+
 ## ⚡ | Serverless Worker (SDK)
 
 This python package can also be used to create a serverless worker that can be deployed to Runpod as a custom endpoint API.

{runpod-2.1.0 → runpod-2.2.0}/README.md

@@ -84,6 +84,18 @@ make setup
 make test
 ```
 
+## Remote values
+
+Queue and task calls use finite JSON-compatible arguments, return values,
+and stream chunks. JSON conversion turns tuples into lists and supported
+dictionary keys into strings, including in same-worker remote calls.
+Bytes, custom objects, circular references, and non-finite numbers produce
+explicit errors. `.local()` remains a direct Python call.
+
+Successful function responses contain `json_result`, including for a null
+return value. SDK and worker runtimes share the JSON protocol validators;
+use compatible package releases when building worker images.
+
 ## ⚡ | Serverless Worker (SDK)
 
 This python package can also be used to create a serverless worker that can be deployed to Runpod as a custom endpoint API.

{runpod-2.1.0 → runpod-2.2.0}/docs/cli/references/command_line_interface.md

@@ -23,6 +23,10 @@ rp ssh POD_ID       # open a terminal on a pod
 rp pod list
 rp pod create
 rp pod connect POD_ID
+
+# Network volume files
+rp volume upload VOLUME ./dataset datasets/dataset
+rp volume download VOLUME outputs/ ./outputs
 ```
 
 ## Overview
@@ -44,6 +48,7 @@ rp login --profile staging      # save browser credentials in a named profile
 
 Credentials are stored in `~/.runpod/config.toml`.
 Use `--profile NAME` with either login method to update only that profile; the default is `default`.
+Set `RUNPOD_PROFILE=NAME` to select the profile for all commands and for `runpod` in Python; `--profile` overrides it, and `RUNPOD_API_KEY` overrides any stored profile.
 
 ### Flash apps
 
@@ -62,3 +67,38 @@ entrypoint or a resource function; interrupt discovery if an import blocks.
 On Ctrl-C, a dev session waits for its running local entrypoint to finish before
 deleting endpoints. Blocking entrypoint code can delay shutdown. Cleanup failures
 exit with an error and report the endpoint IDs that still need deletion.
+
+### Network volume files
+
+```bash
+rp volume upload VOLUME ./model.safetensors models/
+rp volume upload VOLUME ./dataset datasets/dataset
+rp volume download VOLUME models/model.safetensors
+rp volume download VOLUME outputs/ ./outputs
+```
+
+Transfers use the volume's S3-compatible API, so they need S3 API keys
+(separate from the API key): set `RUNPOD_S3_ACCESS_KEY` and
+`RUNPOD_S3_SECRET_KEY`, pass `--s3-access-key` / `--s3-secret-key`, or save
+`s3_access_key` / `s3_secret_key` in `~/.runpod/config.toml`. The CLI prompts
+for missing keys and offers to save them. You can omit `VOLUME` in an
+interactive session to pick a volume from a list. The
+volume must be in a [datacenter with the S3 API](https://docs.runpod.io/storage/s3-api).
+`VOLUME` is the volume's ID or name, looked up with your API key.
+
+To resume an interrupted transfer, run the same command again. Files that
+are unchanged (same size, destination not older) are skipped, a large upload
+reuses the parts it already sent, and a large download keeps its finished
+chunks in `<name>.rpdownload`. `--force` transfers every file. Parts of an
+upload that is never resumed stay in the volume's hidden `.s3compat_uploads`
+folder and count toward its size.
+
+The same transfers are available from Python:
+
+```python
+from runpod import NetworkVolume
+
+volume = NetworkVolume("my-volume")
+volume.upload("./dataset", "datasets/dataset")
+volume.download("outputs/", "./outputs")
+```

{runpod-2.1.0 → runpod-2.2.0}/docs/cli/start_here.md

@@ -12,6 +12,8 @@ Store your Runpod API key by running `rp login` (approve in the browser, then pa
 
 Pass `--profile staging` with either login method to update a named credential profile without changing the others. The default profile is `default`.
 
+Set `RUNPOD_PROFILE=staging` to use that profile for every command, including `rp login`. `--profile` takes precedence over `RUNPOD_PROFILE`, and `RUNPOD_API_KEY` takes precedence over any stored profile.
+
 ### SSH
 
 Add an SSH key to your account by running `rp ssh add`. To use an existing key pass `--key` or `--key-file`. Keys are stored in `~/.runpod/ssh/`. If no key is specified a new one is generated and stored.

runpod-2.2.0/docs/getting_started.md

@@ -0,0 +1,34 @@
+# Getting Started
+
+The Runpod python library is a powerful library providing SDK functions, API access, and CLI commands for interacting with the Runpod platform.
+
+## Credentials File
+
+`rp login` stores your API key in `~/.runpod/config.toml`, one table per profile:
+
+```toml
+[default]
+api_key = "YOUR_RUNPOD_API_KEY"
+```
+
+### Profile
+
+By default, credentials are stored under and read from the `default` profile. To store a key under another profile, pass `--profile` to `rp login`:
+
+```bash
+rp login --profile my_profile
+```
+
+To use that profile, set the `RUNPOD_PROFILE` environment variable before importing `runpod`. The library reads the profile and its API key once, at import time.
+
+```bash
+export RUNPOD_PROFILE=my_profile
+```
+
+`RUNPOD_API_KEY`, when set, takes precedence over any stored profile. Inside a script, you can also set the key directly:
+
+```python
+import runpod
+
+runpod.api_key = "YOUR_RUNPOD_API_KEY"
+```

{runpod-2.1.0 → runpod-2.2.0}/requirements.txt

@@ -5,7 +5,6 @@ backoff >= 2.2.1
 boto3 >= 1.43.118
 certifi >= 2026.10.19
 click >= 8.5.0
-cloudpickle >= 3.1.2
 colorama >= 0.4.6, < 0.4.7
 cryptography >= 50.0.2
 fastapi[all] >= 0.162.0

{runpod-2.1.0 → runpod-2.2.0}/runpod/__init__.py

@@ -54,6 +54,7 @@ _LAZY_ATTRS = {
     "Model": "runpod.apps",
     "NetworkVolume": "runpod.apps",
     "Queue": "runpod.apps",
+    "Task": "runpod.apps",
     "Secret": "runpod.apps",
     "Volume": "runpod.apps",
     "is_local": "runpod.apps",
@@ -86,6 +87,18 @@ __all__ = [
 ]
 
 
+DEFAULT_PROFILE = "default"
+
+
+def _selected_profile() -> str:
+    """credential profile in ~/.runpod/config.toml to use.
+
+    set RUNPOD_PROFILE to pick a named profile (saved with
+    `rp login --profile NAME`); unset or blank means "default".
+    """
+    return os.environ.get("RUNPOD_PROFILE", "").strip() or DEFAULT_PROFILE
+
+
 def _load_api_key():
     """resolve the api key from the environment, then stored credentials.
 
@@ -102,7 +115,7 @@ def _load_api_key():
         ).get_credentials(profile)
     except Exception:  # noqa: BLE001 - no stored key is a valid state
         return None
-    return creds["api_key"] if creds else None
+    return creds.get("api_key") if creds else None
 
 
 def __getattr__(name):
@@ -118,7 +131,7 @@ def __getattr__(name):
 # ------------------------------- Config Paths ------------------------------- #
 SSH_KEY_PATH = os.path.expanduser("~/.runpod/ssh")
 
-profile = "default"  # pylint: disable=invalid-name
+profile = _selected_profile()  # pylint: disable=invalid-name
 
 api_key = _load_api_key()  # pylint: disable=invalid-name
 

runpod-2.2.0/runpod/_hosts.py

@@ -0,0 +1,54 @@
+"""Service hosts used to build console, proxy, and endpoint URLs.
+
+Each host can be overridden with an environment variable, which is read on
+every call so a change takes effect without re-importing ``runpod``. Unset or
+blank values fall back to the public Runpod hosts.
+
+    RUNPOD_CONSOLE_URL        web console base URL (default https://console.runpod.io)
+    RUNPOD_PROXY_DOMAIN       pod HTTP proxy domain (default proxy.runpod.net)
+    RUNPOD_ENDPOINT_BASE_URL  serverless base URL (default https://api.runpod.ai/v2)
+
+The endpoint domain is the host of ``RUNPOD_ENDPOINT_BASE_URL``. When that is
+unset or blank, a non-blank ``runpod.endpoint_url_base`` set programmatically
+is used instead.
+
+Example:
+    >>> proxy_url("abc123", 8080)
+    'https://abc123-8080.proxy.runpod.net'
+"""
+
+import os
+from typing import Union
+
+DEFAULT_CONSOLE_URL = "https://console.runpod.io"
+DEFAULT_PROXY_DOMAIN = "proxy.runpod.net"
+DEFAULT_ENDPOINT_BASE_URL = "https://api.runpod.ai/v2"
+
+
+def _env(name: str, default: str) -> str:
+    value = os.environ.get(name, "").strip()
+    return value or default
+
+
+def console_url() -> str:
+    """Web console base URL, without a trailing slash."""
+    return _env("RUNPOD_CONSOLE_URL", DEFAULT_CONSOLE_URL).rstrip("/")
+
+
+def proxy_url(pod_id: str, port: Union[int, str]) -> str:
+    """Public HTTP proxy URL for ``port`` on ``pod_id``."""
+    domain = _env("RUNPOD_PROXY_DOMAIN", DEFAULT_PROXY_DOMAIN).strip("/")
+    return f"https://{pod_id}-{port}.{domain}"
+
+
+def endpoint_domain() -> str:
+    """Host of the serverless data plane, e.g. ``api.runpod.ai``.
+
+    Load-balanced endpoints are served on ``<endpoint_id>.<endpoint_domain>``.
+    """
+    import runpod
+
+    module_base = (runpod.endpoint_url_base or "").strip()
+    base = _env("RUNPOD_ENDPOINT_BASE_URL", module_base or DEFAULT_ENDPOINT_BASE_URL)
+    host = base.split("://", 1)[-1]
+    return host.split("/", 1)[0]

runpod-2.2.0/runpod/_serialization.py

@@ -0,0 +1,21 @@
+"""finite json validation and wire-value conversion for callers and workers."""
+
+import json
+from typing import Any
+
+
+def _json_text(value: Any, label: str) -> str:
+    try:
+        return json.dumps(value, allow_nan=False)
+    except (TypeError, ValueError, RecursionError) as exc:
+        raise TypeError(f"{label} must be json-serializable: {exc}") from exc
+
+
+def validate_json(value: Any, label: str = "value") -> None:
+    """require values encodable as finite json."""
+    _json_text(value, label)
+
+
+def normalize_json(value: Any, label: str = "value") -> Any:
+    """apply json's container and key conversions without a network roundtrip."""
+    return json.loads(_json_text(value, label))

{runpod-2.1.0 → runpod-2.2.0}/runpod/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.0'
-__version_tuple__ = version_tuple = (2, 1, 0)
+__version__ = version = '2.2.0'
+__version_tuple__ = version_tuple = (2, 2, 0)
 
-__commit_id__ = commit_id = 'g0d59088b9'
+__commit_id__ = commit_id = 'g89d72b8c4'

runpod-2.2.0/runpod/_volume_transfer_utils.py

@@ -0,0 +1,171 @@
+"""Filesystem and checksum helpers for resumable transfers.
+
+This private module keeps disk state and path safety details out of the S3
+request orchestration. network_volume_transfer re-exports the error type.
+"""
+
+import hashlib
+import json
+import os
+import unicodedata
+from pathlib import Path, PurePosixPath
+from typing import Any, Dict, List, Optional
+
+MIB = 1024 * 1024
+PARTIAL_SUFFIX = ".rpdownload"
+SIDECAR_SUFFIX = ".rpdownload.json"
+# every file a download writes next to its target
+TRANSFER_SUFFIXES = (PARTIAL_SUFFIX, SIDECAR_SUFFIX, SIDECAR_SUFFIX + ".tmp")
+
+
+class NetworkVolumeTransferError(RuntimeError):
+    """a transfer failed. `resumable` says whether re-running can help."""
+
+    def __init__(self, message: str, resumable: bool = False):
+        super().__init__(message)
+        self.resumable = resumable
+
+
+def _read_json(path: Path) -> Optional[Dict[str, Any]]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _write_json(path: Path, data: Dict[str, Any]) -> None:
+    """replace path atomically, synced, so a crash leaves the old state or
+    the new one."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".tmp")
+    with open(tmp, "w", encoding="utf-8") as handle:
+        json.dump(data, handle)
+        handle.flush()
+        os.fsync(handle.fileno())
+    os.replace(tmp, path)
+    _sync_dir(path.parent)
+
+
+def _sync_dir(path: Path) -> None:
+    """make a rename in path survive a power loss. best effort: windows
+    cannot open a directory."""
+    try:
+        fd = os.open(path, os.O_RDONLY)
+    except OSError:
+        return
+    try:
+        os.fsync(fd)
+    except OSError:
+        # some filesystems refuse fsync on a directory; the rename stands
+        pass
+    finally:
+        os.close(fd)
+
+
+def _md5_hex(path: Path, offset: int, length: int) -> str:
+    digest = hashlib.md5()  # noqa: S324 - etag comparison, not security
+    with open(path, "rb") as handle:
+        handle.seek(offset)
+        while length > 0 and (block := handle.read(min(8 * MIB, length))):
+            digest.update(block)
+            length -= len(block)
+    return digest.hexdigest()
+
+
+def _etag(value: Any) -> str:
+    return str(value or "").strip('"')
+
+
+def _is_md5(etag: str) -> bool:
+    return len(etag) == 32 and all(c in "0123456789abcdef" for c in etag.lower())
+
+
+def _multipart_etag(parts: List[Dict[str, Any]]) -> str:
+    """the etag s3 (and runpod, verified) gives an object assembled from
+    parts: md5 of the parts' binary md5s, then "-<count>". "" when a part
+    etag is not an md5."""
+    etags = [_etag(part["ETag"]) for part in parts]
+    if not all(_is_md5(etag) for etag in etags):
+        return ""
+    digest = hashlib.md5(b"".join(bytes.fromhex(etag) for etag in etags))  # noqa: S324
+    return f"{digest.hexdigest()}-{len(parts)}"
+
+
+def _same_version(a: os.stat_result, b: os.stat_result) -> bool:
+    return a.st_size == b.st_size and a.st_mtime_ns == b.st_mtime_ns
+
+
+def _not_older(a: float, b: float) -> bool:
+    """a >= b in whole seconds; s3 dates carry no finer precision."""
+    return int(a) >= int(b)
+
+
+def _check_remote_path(remote_path: Optional[str]) -> None:
+    if remote_path and ".." in remote_path.replace("\\", "/").split("/"):
+        raise ValueError(f"remote path {remote_path!r} must not contain '..'")
+
+
+def _check_local_names(targets: List[Path], root: Path) -> None:
+    """refuse targets that would share a path on disk: two that are one name
+    on a case-insensitive or normalizing filesystem ("Model.bin" and
+    "model.bin"), a file whose name is also a folder another file lives in
+    ("a" beside "A/b"), or a file whose partial, sidecar or sidecar temp name
+    is also a target or a folder one lives in ("x" beside "x.rpdownload/y").
+    names are compared nfc-normalized (apfs ignores normalization) and case
+    folded, which can refuse a listing a case-sensitive filesystem would
+    take: the safe direction."""
+
+    def fold(path: PurePosixPath) -> str:
+        return unicodedata.normalize("NFC", str(path)).casefold()
+
+    rels = [PurePosixPath(target.relative_to(root).as_posix()) for target in targets]
+    files: Dict[str, PurePosixPath] = {}
+    dirs: Dict[str, PurePosixPath] = {}
+    for rel in rels:
+        if fold(rel) in files:
+            raise NetworkVolumeTransferError(
+                f"cannot download both {files[fold(rel)]} and {rel}: they would be one "
+                "file on a case-insensitive or normalizing filesystem"
+            )
+        files[fold(rel)] = rel
+        dirs.update({fold(parent): rel for parent in rel.parents if str(parent) != "."})
+    for rel in rels:
+        if fold(rel) in dirs:
+            raise NetworkVolumeTransferError(
+                f"cannot download both {rel} and {dirs[fold(rel)]}: "
+                "the first would have to be a file and a folder"
+            )
+        for suffix in TRANSFER_SUFFIXES:
+            twin = fold(rel.with_name(rel.name + suffix))
+            other = files.get(twin) or dirs.get(twin)
+            if other is not None:
+                raise NetworkVolumeTransferError(
+                    f"cannot download both {rel} and {other}: "
+                    f"{rel.name + suffix} is used for the first's partial download"
+                )
+
+
+def _safe_target(root: Path, rel: str) -> Path:
+    """local path for a remote relative key, refusing anything outside root.
+    "." and empty segments are refused too: "a/./b" would alias "a/b"."""
+    segments = rel.split("/")
+    if (
+        rel.startswith("/")
+        or "\\" in rel
+        or any(seg in ("..", ".", "") for seg in segments)
+        or ":" in segments[0]
+    ):
+        raise NetworkVolumeTransferError(f"refusing unsafe remote path: {rel!r}")
+    target = root.joinpath(*segments)
+    if root.resolve() not in target.resolve().parents:
+        raise NetworkVolumeTransferError(f"refusing unsafe remote path: {rel!r}")
+    # a symlinked folder would let two remote paths share one local file,
+    # which the name collision check cannot see
+    for depth in range(1, len(segments)):
+        if root.joinpath(*segments[:depth]).is_symlink():
+            raise NetworkVolumeTransferError(
+                f"{root.joinpath(*segments[:depth])} is a symlink; "
+                "download into a folder without symlinked subfolders"
+            )
+    return target

{runpod-2.1.0 → runpod-2.2.0}/runpod/api/graphql.py

@@ -87,6 +87,7 @@ async def run_graphql_query_async(
     variables: Optional[Dict[str, Any]] = None,
     timeout: float = 60.0,
     anonymous: bool = False,
+    headers: Optional[Dict[str, str]] = None,
 ) -> Dict[str, Any]:
     """
     Async variant of run_graphql_query, sharing the same url, headers,
@@ -109,7 +110,7 @@ async def run_graphql_query_async(
     async with aiohttp.ClientSession(timeout=client_timeout) as session:
         async with session.post(
             _graphql_url(),
-            headers=_build_headers(effective_api_key),
+            headers={**_build_headers(effective_api_key), **(headers or {})},
             json=_build_payload(query, variables),
         ) as response:
             if response.status == HTTP_STATUS_UNAUTHORIZED:

{runpod-2.1.0 → runpod-2.2.0}/runpod/api/mutations/apps.py

@@ -92,6 +92,12 @@ mutation FinalizeArtifactUpload($input: FinalizeFlashArtifactUploadInput!) {
 }
 """
 
+MUTATION_FINALIZE_TASK_ARTIFACT_UPLOAD = """
+mutation FinalizeArtifactUpload($input: FinalizeFlashArtifactUploadInput!) {
+    finalizeFlashArtifactUpload(input: $input) { id manifest resourceSpec }
+}
+"""
+
 MUTATION_DEPLOY_BUILD = """
 mutation deployBuildToEnvironment($input: DeployBuildToEnvironmentInput!) {
     deployBuildToEnvironment(input: $input) { id name }

{runpod-2.1.0 → runpod-2.2.0}/runpod/apps/__init__.py

@@ -15,7 +15,7 @@ from .job import Job
 from .markers import delete, get, init, patch, post, put
 from .schedule import schedule
 from .spec import ResourceKind, ResourceSpec, RouteSpec
-from .stubs import Api, Queue
+from .stubs import Api, Queue, Task
 from .model import Model
 from .secret import Secret
 from .volume import GlobalVolume, NetworkVolume, Volume
@@ -34,6 +34,7 @@ __all__ = [
     "Model",
     "NetworkVolume",
     "Queue",
+    "Task",
     "Secret",
     "Volume",
     "RemoteExecutionError",

{runpod-2.1.0 → runpod-2.2.0}/runpod/apps/api.py

@@ -20,6 +20,46 @@ from ..error import AuthenticationError, QueryError
 _TRANSPORT_RETRIES = 4
 
 
+class FlashTaskApiClient:
+    """named task lifecycle operations with runtime-scoped authentication."""
+
+    async def _execute(self, query: str, task_input: Dict[str, Any]) -> Dict[str, Any]:
+        from .utils.network import api_key, runtime_headers
+
+        headers = runtime_headers()
+        response = await run_graphql_query_async(
+            query,
+            variables={"input": task_input},
+            api_key=(headers["Authorization"][7:] if headers else api_key()),
+            headers=headers,
+        )
+        return response["data"]
+
+    async def create(self, task_input: Dict[str, Any]) -> Dict[str, Any]:
+        from .utils.network import validate_runtime_target
+
+        validate_runtime_target(
+            task_input.get("flashAppName"), task_input.get("flashEnvironmentName")
+        )
+        data = await self._execute(
+            """mutation FlashTaskCreate($input: FlashTaskCreateInput!) {
+                flashTaskCreate(input: $input) { podId flashBuildId resourceName }
+            }""",
+            task_input,
+        )
+        return data["flashTaskCreate"]
+
+    async def terminate(self, pod_id: str, token: str) -> None:
+        data = await self._execute(
+            """mutation FlashTaskTerminate($input: FlashTaskTerminateInput!) {
+                flashTaskTerminate(input: $input)
+            }""",
+            {"podId": pod_id, "executionToken": token},
+        )
+        if data.get("flashTaskTerminate") is not True:
+            raise RuntimeError("task termination was not acknowledged")
+
+
 def _rest_endpoint_input(endpoint: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     """translate only saves whose capabilities rest can preserve atomically."""
     fields = {
@@ -583,6 +623,8 @@ class AppsApiClient:
         self, app_id: str, object_key: str, manifest: Dict[str, Any]
     ) -> Dict[str, Any]:
         mutation = app_mutations.MUTATION_FINALIZE_ARTIFACT_UPLOAD
+        if any(r.get("kind") == "task" for r in manifest.get("resources", [])):
+            mutation = app_mutations.MUTATION_FINALIZE_TASK_ARTIFACT_UPLOAD
         data = await self._execute(
             mutation,
             {

{runpod-2.1.0 → runpod-2.2.0}/runpod/apps/app.py

@@ -151,7 +151,11 @@ class App:
         accelerate_downloads: bool = True,
         container_disk_gb: Optional[int] = None,
     ) -> Callable[[Callable], FunctionHandle]:
-        """declare ephemeral pod compute from a function."""
+        """declare ephemeral pod compute from a function.
+
+        remote task arguments and results use json in every execution
+        context. use .local() for direct python execution without transport.
+        """
 
         def decorator(fn: Callable) -> FunctionHandle:
             spec = ResourceSpec(
@@ -259,6 +263,12 @@ class App:
         """resolve a resource spec to an invocation target."""
         spec.validate()
         if spec.kind is ResourceKind.TASK:
+            from .context import deployed_identity
+            from .targets import DeployedTaskTarget
+
+            identity = deployed_identity()
+            if identity is not None:
+                return DeployedTaskTarget(self.name, identity[1], spec.name)
             handle = self._resources.get(spec.name)
             fn = getattr(handle, "_fn", None)
             return PodTarget(