diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index af0be9cd0..3f525eda7 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -68,6 +68,22 @@ This project adheres to the [PEP 8](https://www.python.org/dev/peps/pep-0008/) c Before submitting a pull request, please make sure your changes pass all tests. New features should include additional unit tests validating the changes. +### HTTP Requests + +Use `Route` templates for paths and the shared clients in `runpod.api` for HTTP requests. Route parameters are escaped, and service bases are configured in `runpod.api.routes`. Keep a client context open across related requests to reuse its connection pool. + +```python +from runpod.api.rest import AsyncRESTClient +from runpod.api.routes import Route + +async with AsyncRESTClient() as client: + pod = await client.request(Route("GET", "/v2/pods/{pod_id}", pod_id=pod_id)) +``` + +`RESTClient` provides the synchronous equivalent. Both clients apply account authentication and bounded rate-limit waits. `HTTPClient` and `SyncHTTPClient` in `runpod.api.http` handle raw transport for GraphQL, streams, worker requests, and uploads. These raw clients require explicit authentication headers. Their `stream()` contexts expose responses for protocol-specific handling and release them on exit. A supplied session remains owned by its caller. + +Account login and credential storage belong in `runpod.auth`. CLI commands belong in `runpod.cli`. + ## Getting Help If you have any questions or need help with contributing, feel free to reach out on the [issue tracker](https://github.com/runpod/runpod-python/issues) or open a new issue. We're here to help! diff --git a/pyproject.toml b/pyproject.toml index d514756a0..1b4e2a251 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -60,8 +60,8 @@ local_scheme = "no-local-version" [project.scripts] -runpod = "runpod.rp_cli.main:run" -rp = "runpod.rp_cli.main:run" +runpod = "runpod.cli.main:run" +rp = "runpod.cli.main:run" [dependency-groups] diff --git a/runpod/__init__.py b/runpod/__init__.py index 36f398c3d..ae79617de 100644 --- a/runpod/__init__.py +++ b/runpod/__init__.py @@ -37,9 +37,9 @@ "update_endpoint_template": "runpod.api.ctl_commands", "update_user_settings": "runpod.api.ctl_commands", # config helpers - "check_credentials": "runpod.cli.groups.config.functions", - "get_credentials": "runpod.cli.groups.config.functions", - "set_credentials": "runpod.cli.groups.config.functions", + "check_credentials": "runpod.auth.credentials", + "get_credentials": "runpod.auth.credentials", + "set_credentials": "runpod.auth.credentials", # endpoint clients "AsyncioEndpoint": "runpod.endpoint", "AsyncioJob": "runpod.endpoint", @@ -100,22 +100,10 @@ def _selected_profile() -> str: def _load_api_key(): - """resolve the api key from the environment, then stored credentials. + """resolve the api key from the environment or selected profile.""" + from .auth import load_api_key - the credential lookup is deferred (and tolerant of a missing cli - dependency closure) so a bare `import runpod` never drags in the - config/cli modules; the deployed worker gets its key from the env. - """ - key = os.environ.get("RUNPOD_API_KEY") - if key: - return key - try: - creds = importlib.import_module( - "runpod.cli.groups.config.functions" - ).get_credentials(profile) - except Exception: # noqa: BLE001 - no stored key is a valid state - return None - return creds.get("api_key") if creds else None + return load_api_key(profile) def __getattr__(name): diff --git a/runpod/_hosts.py b/runpod/_hosts.py index ecb669047..84d2337ac 100644 --- a/runpod/_hosts.py +++ b/runpod/_hosts.py @@ -7,6 +7,8 @@ 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) + RUNPOD_API_BASE_URL control-plane base URL (default https://api.runpod.io) + RUNPOD_HAPI_URL host API base URL (default https://hapi.runpod.net) 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 @@ -23,6 +25,8 @@ DEFAULT_CONSOLE_URL = "https://console.runpod.io" DEFAULT_PROXY_DOMAIN = "proxy.runpod.net" DEFAULT_ENDPOINT_BASE_URL = "https://api.runpod.ai/v2" +DEFAULT_API_BASE_URL = "https://api.runpod.io" +DEFAULT_HOST_API_URL = "https://hapi.runpod.net" def _env(name: str, default: str) -> str: @@ -35,6 +39,26 @@ def console_url() -> str: return _env("RUNPOD_CONSOLE_URL", DEFAULT_CONSOLE_URL).rstrip("/") +def api_base_url() -> str: + """control-plane API base URL.""" + return _env("RUNPOD_API_BASE_URL", DEFAULT_API_BASE_URL).rstrip("/") + + +def host_api_base_url() -> str: + """host API base URL for pod log snapshots.""" + return _env("RUNPOD_HAPI_URL", DEFAULT_HOST_API_URL).rstrip("/") + + +def endpoint_base_url() -> str: + """serverless API base URL with environment and module overrides.""" + import runpod + + module_base = (runpod.endpoint_url_base or "").strip() + return _env( + "RUNPOD_ENDPOINT_BASE_URL", module_base or DEFAULT_ENDPOINT_BASE_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("/") @@ -46,9 +70,6 @@ def endpoint_domain() -> str: Load-balanced endpoints are served on ``.``. """ - import runpod - - module_base = (runpod.endpoint_url_base or "").strip() - base = _env("RUNPOD_ENDPOINT_BASE_URL", module_base or DEFAULT_ENDPOINT_BASE_URL) + base = endpoint_base_url() host = base.split("://", 1)[-1] return host.split("/", 1)[0] diff --git a/runpod/api/graphql.py b/runpod/api/graphql.py index 48bd264db..d26d168e9 100644 --- a/runpod/api/graphql.py +++ b/runpod/api/graphql.py @@ -3,29 +3,16 @@ """ import json -import os from typing import Any, Dict, Optional -import requests - from runpod import error +from runpod.auth import resolve_api_key as _resolve_api_key from runpod.user_agent import USER_AGENT -HTTP_STATUS_UNAUTHORIZED = 401 - - -def _graphql_url() -> str: - api_url_base = os.environ.get("RUNPOD_API_BASE_URL", "https://api.runpod.io") - return f"{api_url_base}/graphql" - +from .http import HTTPClient, SyncHTTPClient +from .routes import Route -def _resolve_api_key(api_key: Optional[str]) -> str: - from runpod import api_key as global_api_key # pylint: disable=import-outside-toplevel, cyclic-import - - effective_api_key = api_key or global_api_key - if not effective_api_key: - raise error.AuthenticationError("No API key provided") - return effective_api_key +HTTP_STATUS_UNAUTHORIZED = 401 def _build_headers(api_key: Optional[str]) -> Dict[str, str]: @@ -66,19 +53,17 @@ def run_graphql_query( """ effective_api_key = _resolve_api_key(api_key) - response = requests.post( - _graphql_url(), + with SyncHTTPClient().stream( + Route("POST", "/graphql"), headers=_build_headers(effective_api_key), data=json.dumps(_build_payload(query, variables)), timeout=30, - ) - - if response.status_code == HTTP_STATUS_UNAUTHORIZED: - raise error.AuthenticationError( - "Unauthorized request, please check your API key." - ) - - return _check_response(response.json(), query) + ) as response: + if response.status_code == HTTP_STATUS_UNAUTHORIZED: + raise error.AuthenticationError( + "Unauthorized request, please check your API key." + ) + return _check_response(response.json(), query) async def run_graphql_query_async( @@ -102,21 +87,18 @@ async def run_graphql_query_async( is available. Login creates its auth request this way so a stale stored key cannot fail the request. """ - import aiohttp # pylint: disable=import-outside-toplevel - effective_api_key = None if anonymous else _resolve_api_key(api_key) - client_timeout = aiohttp.ClientTimeout(total=timeout) - async with aiohttp.ClientSession(timeout=client_timeout) as session: - async with session.post( - _graphql_url(), - headers={**_build_headers(effective_api_key), **(headers or {})}, - json=_build_payload(query, variables), - ) as response: - if response.status == HTTP_STATUS_UNAUTHORIZED: - raise error.AuthenticationError( - "Unauthorized request, please check your API key." - ) - response_json = await response.json() + async with HTTPClient().stream( + Route("POST", "/graphql"), + headers={**_build_headers(effective_api_key), **(headers or {})}, + json=_build_payload(query, variables), + timeout=timeout, + ) as response: + if response.status == HTTP_STATUS_UNAUTHORIZED: + raise error.AuthenticationError( + "Unauthorized request, please check your API key." + ) + response_json = await response.json() return _check_response(response_json, query) diff --git a/runpod/api/http.py b/runpod/api/http.py new file mode 100644 index 000000000..22977dd32 --- /dev/null +++ b/runpod/api/http.py @@ -0,0 +1,138 @@ +"""shared HTTP sessions, request lifetimes, and response decoding.""" + +from contextlib import asynccontextmanager, contextmanager +from typing import Mapping + +import aiohttp +import requests +from yarl import URL + +from runpod.user_agent import USER_AGENT + +from .routes import Route, api_base_url + + +class HTTPClient: + """an async transport with an explicitly scoped connection pool.""" + + def __init__( + self, + base_url: str | None = None, + *, + headers: Mapping[str, str] | None = None, + session: aiohttp.ClientSession | None = None, + ): + self.base_url = api_base_url() if base_url is None else base_url + self.headers = {"User-Agent": USER_AGENT} if session is None else {} + self.headers.update(headers or {}) + self.session = session + self._owns_session = session is None + + async def __aenter__(self): + if self.session is None: + self.session = aiohttp.ClientSession(cookie_jar=aiohttp.DummyCookieJar()) + elif self.session.closed: + raise RuntimeError("the supplied HTTP session is closed") + self.session._retry_connection = False + return self + + async def __aexit__(self, *args): + await self.close() + + async def close(self): + if self._owns_session and self.session is not None: + session, self.session = self.session, None + await session.close() + + @asynccontextmanager + async def stream(self, route: Route, *, timeout=30, headers=None, **kwargs): + if self.session is None: + async with HTTPClient(self.base_url, headers=self.headers) as client: + async with client.stream( + route, timeout=timeout, headers=headers, **kwargs + ) as response: + yield response + return + self.session._retry_connection = False + if not isinstance(timeout, aiohttp.ClientTimeout): + timeout = aiohttp.ClientTimeout(total=timeout) + kwargs.setdefault("allow_redirects", False) + async with self.session.request( + route.method, + URL(route.url(self.base_url), encoded=True), + headers={**self.headers, **(headers or {})}, + timeout=timeout, + **kwargs, + ) as response: + yield response + + async def request(self, route: Route, *, response_type="json", **kwargs): + if response_type not in {"json", "text"}: + raise ValueError("response_type must be json or text") + async with self.stream(route, **kwargs) as response: + response.raise_for_status() + if 300 <= response.status < 400: + raise aiohttp.ClientResponseError( + response.request_info, + response.history, + status=response.status, + message="unexpected redirect", + headers=response.headers, + ) + if response_type == "text": + return await response.text() + if response.status == 204 or not await response.read(): + return None + return await response.json(content_type=None) + + +class SyncHTTPClient: + """a synchronous transport with the same routes and ownership rules.""" + + def __init__( + self, + base_url: str | None = None, + *, + headers: Mapping[str, str] | None = None, + session: requests.Session | None = None, + ): + self.base_url = api_base_url() if base_url is None else base_url + self.headers = {"User-Agent": USER_AGENT} if session is None else {} + self.headers.update(headers or {}) + self.session = session + self._owns_session = session is None + + def __enter__(self): + if self.session is None: + self.session = requests.Session() + return self + + def __exit__(self, *args): + self.close() + + def close(self): + if self._owns_session and self.session is not None: + session, self.session = self.session, None + session.close() + + @contextmanager + def stream(self, route: Route, *, timeout=30, headers=None, **kwargs): + if self.session is None: + with SyncHTTPClient(self.base_url, headers=self.headers) as client: + with client.stream( + route, timeout=timeout, headers=headers, **kwargs + ) as response: + yield response + return + kwargs.setdefault("allow_redirects", False) + response = self.session.request( + route.method, + route.url(self.base_url), + headers={**self.headers, **(headers or {})}, + timeout=timeout, + **kwargs, + ) + try: + yield response + finally: + response.close() diff --git a/runpod/api/mutations/apps.py b/runpod/api/mutations/apps.py index 1b549580e..5f1a3da5e 100644 --- a/runpod/api/mutations/apps.py +++ b/runpod/api/mutations/apps.py @@ -66,16 +66,6 @@ } """ -MUTATION_CREATE_FLASH_AUTH_REQUEST = """ -mutation createFlashAuthRequest { - createFlashAuthRequest { - id - status - expiresAt - } -} -""" - MUTATION_PREPARE_ARTIFACT_UPLOAD = """ mutation PrepareArtifactUpload($input: PrepareFlashArtifactUploadInput!) { prepareFlashArtifactUpload(input: $input) { diff --git a/runpod/api/queries/apps.py b/runpod/api/queries/apps.py index c5b11ac3e..db61383d1 100644 --- a/runpod/api/queries/apps.py +++ b/runpod/api/queries/apps.py @@ -65,13 +65,3 @@ } } """ - -# no apiKey: the console shows the key only to the approver. -QUERY_FLASH_AUTH_REQUEST_STATUS = """ -query flashAuthRequestStatus($flashAuthRequestId: String!) { - flashAuthRequestStatus(flashAuthRequestId: $flashAuthRequestId) { - id - status - } -} -""" diff --git a/runpod/api/rest.py b/runpod/api/rest.py index 4cfb4a935..292c4efe6 100644 --- a/runpod/api/rest.py +++ b/runpod/api/rest.py @@ -2,19 +2,19 @@ import asyncio import json as json_module -import os import time from concurrent.futures import Future -from contextlib import nullcontext from typing import Any, Mapping, Optional import aiohttp -import requests from runpod import error +from runpod.auth import resolve_api_key as _resolve_api_key from runpod.user_agent import USER_AGENT from ._rate_limit import _RetryBudget, _validate_retry_options, rate_limits +from .http import HTTPClient, SyncHTTPClient +from .routes import Route HTTP_STATUS_NO_CONTENT = 204 HTTP_STATUS_BAD_REQUEST = 400 @@ -22,20 +22,8 @@ HTTP_STATUS_NOT_FOUND = 404 -def _resolve_api_key(api_key: Optional[str]) -> str: - from runpod import ( # pylint: disable=import-outside-toplevel,cyclic-import - api_key as global_api_key, - ) - - effective_api_key = api_key or global_api_key - if not effective_api_key: - raise error.AuthenticationError("No API key provided") - return effective_api_key - - def _build_url(path: str) -> str: - api_url_base = os.environ.get("RUNPOD_API_BASE_URL", "https://api.runpod.io") - return f"{api_url_base.rstrip('/')}/{path.lstrip('/')}" + return Route("GET", path).url() def _build_headers(api_key: str) -> dict[str, str]: @@ -88,106 +76,116 @@ def _raise_for_error( ) -def run_rest_request( - method: str, - path: str, - *, - api_key: Optional[str] = None, - params: Optional[Mapping[str, Any]] = None, - json: Optional[Mapping[str, Any]] = None, - timeout: float = 30, - max_retries: int = 3, - max_rate_limit_wait: float = 60, - user_agent: str = USER_AGENT, -) -> Optional[dict[str, Any]]: - """Send a REST request with bounded 429 retries and shared quota waits. +class RESTClient(SyncHTTPClient): + """reusable synchronous REST requests with shared quota handling.""" - ``timeout`` applies to each HTTP attempt. ``max_rate_limit_wait`` bounds - cumulative quota sleeps in seconds; ``max_retries`` counts 429 retries. - Network failures and other HTTP errors are not retried. - """ - _validate_retry_options(max_retries, max_rate_limit_wait) - key = _resolve_api_key(api_key) - url = _build_url(path) - headers = _build_headers(key) - headers["User-Agent"] = user_agent - budget = _RetryBudget(max_retries, max_rate_limit_wait, f"{method.upper()} {path}") - with rate_limits.bucket(url, key) as bucket: - for attempt in range(max_retries + 1): - while wait := bucket.acquire(budget): - if isinstance(wait, Future): - wait.result() - else: - time.sleep(wait) - try: - started_at = time.monotonic() - response = requests.request( - method, - url, - headers=headers, - params=params, - json=json, - timeout=timeout, - ) + def __init__(self, api_key=None, *, base_url=None, session=None): + super().__init__(base_url, session=session) + self.api_key = api_key + + def request( + self, + route: Route, + *, + api_key: Optional[str] = None, + params: Optional[Mapping[str, Any]] = None, + json: Optional[Mapping[str, Any]] = None, + timeout: float = 30, + max_retries: int = 3, + max_rate_limit_wait: float = 60, + user_agent: str = USER_AGENT, + ) -> Optional[dict[str, Any]]: + """Send a REST request with bounded 429 retries and shared quota waits. + + ``timeout`` applies to each HTTP attempt. ``max_rate_limit_wait`` bounds + cumulative quota sleeps in seconds; ``max_retries`` counts 429 retries. + Network failures and other HTTP errors are not retried. + """ + method, path = route.method, route.resolved_path + _validate_retry_options(max_retries, max_rate_limit_wait) + key = _resolve_api_key(api_key or self.api_key) + url = route.url(self.base_url) + headers = _build_headers(key) + headers["User-Agent"] = user_agent + budget = _RetryBudget( + max_retries, max_rate_limit_wait, f"{method.upper()} {path}" + ) + with rate_limits.bucket(url, key) as bucket: + for attempt in range(max_retries + 1): + while wait := bucket.acquire(budget): + if isinstance(wait, Future): + wait.result() + else: + time.sleep(wait) try: - retry_after = bucket.update( - response.status_code, - response.headers, - attempt, - started_at=started_at, - ) - if budget.can_retry(attempt, retry_after): - continue - if response.status_code >= HTTP_STATUS_BAD_REQUEST: - _raise_for_error( + started_at = time.monotonic() + with self.stream( + route, + headers=headers, + params=params, + json=json, + timeout=timeout, + ) as response: + retry_after = bucket.update( response.status_code, - method, - path, - response.text, - retry_after, + response.headers, + attempt, + started_at=started_at, ) - if ( - response.status_code == HTTP_STATUS_NO_CONTENT - or not response.content - ): - return None - return response.json() + if budget.can_retry(attempt, retry_after): + continue + if response.status_code >= HTTP_STATUS_BAD_REQUEST: + _raise_for_error( + response.status_code, + method, + path, + response.text, + retry_after, + ) + if ( + response.status_code == HTTP_STATUS_NO_CONTENT + or not response.content + ): + return None + return response.json() finally: - response.close() - finally: - bucket.release() + bucket.release() -async def run_rest_request_async( - method: str, - path: str, - *, - api_key: Optional[str] = None, - params: Optional[Mapping[str, Any]] = None, - json: Optional[Mapping[str, Any]] = None, - timeout: float = 30, - max_retries: int = 3, - max_rate_limit_wait: float = 60, - session: Optional[aiohttp.ClientSession] = None, - user_agent: str = USER_AGENT, -) -> Optional[dict[str, Any]]: - """Send a REST request with cancellable quota waits and bounded 429 retries. +class AsyncRESTClient(HTTPClient): + """reusable async REST requests with cancellable quota handling.""" + + def __init__(self, api_key=None, *, base_url=None, session=None): + super().__init__(base_url, session=session) + self.api_key = api_key - ``timeout`` applies to each HTTP attempt. ``max_rate_limit_wait`` bounds - cumulative quota sleeps in seconds; ``max_retries`` counts 429 retries. - Network failures and other HTTP errors are not retried. - """ - _validate_retry_options(max_retries, max_rate_limit_wait) - key = _resolve_api_key(api_key) - url = _build_url(path) - headers = _build_headers(key) - headers["User-Agent"] = user_agent - budget = _RetryBudget(max_retries, max_rate_limit_wait, f"{method.upper()} {path}") - client_timeout = aiohttp.ClientTimeout(total=timeout) - context = nullcontext(session) if session is not None else aiohttp.ClientSession() - async with context as session: - # aiohttp otherwise replays put/delete requests after an ambiguous disconnect. - session._retry_connection = False # pylint: disable=protected-access + async def request( + self, + route: Route, + *, + api_key: Optional[str] = None, + params: Optional[Mapping[str, Any]] = None, + json: Optional[Mapping[str, Any]] = None, + timeout: float = 30, + max_retries: int = 3, + max_rate_limit_wait: float = 60, + user_agent: str = USER_AGENT, + ) -> Optional[dict[str, Any]]: + """Send a REST request with cancellable quota waits and bounded 429 retries. + + ``timeout`` applies to each HTTP attempt. ``max_rate_limit_wait`` bounds + cumulative quota sleeps in seconds; ``max_retries`` counts 429 retries. + Network failures and other HTTP errors are not retried. + """ + method, path = route.method, route.resolved_path + _validate_retry_options(max_retries, max_rate_limit_wait) + key = _resolve_api_key(api_key or self.api_key) + url = route.url(self.base_url) + headers = _build_headers(key) + headers["User-Agent"] = user_agent + budget = _RetryBudget( + max_retries, max_rate_limit_wait, f"{method.upper()} {path}" + ) with rate_limits.bucket(url, key) as bucket: for attempt in range(max_retries + 1): while wait := bucket.acquire(budget): @@ -197,13 +195,12 @@ async def run_rest_request_async( await asyncio.sleep(wait) try: started_at = time.monotonic() - async with session.request( - method, - url, + async with self.stream( + route, headers=headers, params=params, json=json, - timeout=client_timeout, + timeout=timeout, ) as response: retry_after = bucket.update( response.status, @@ -232,6 +229,57 @@ async def run_rest_request_async( bucket.release() +def run_rest_request( + method: str, + path: str, + *, + api_key: Optional[str] = None, + params: Optional[Mapping[str, Any]] = None, + json: Optional[Mapping[str, Any]] = None, + timeout: float = 30, + max_retries: int = 3, + max_rate_limit_wait: float = 60, + user_agent: str = USER_AGENT, +) -> Optional[dict[str, Any]]: + """send one REST request and close its connection pool.""" + with RESTClient(api_key) as client: + return client.request( + Route(method, path), + params=params, + json=json, + timeout=timeout, + max_retries=max_retries, + max_rate_limit_wait=max_rate_limit_wait, + user_agent=user_agent, + ) + + +async def run_rest_request_async( + method: str, + path: str, + *, + api_key: Optional[str] = None, + params: Optional[Mapping[str, Any]] = None, + json: Optional[Mapping[str, Any]] = None, + timeout: float = 30, + max_retries: int = 3, + max_rate_limit_wait: float = 60, + user_agent: str = USER_AGENT, + session: Optional[aiohttp.ClientSession] = None, +) -> Optional[dict[str, Any]]: + """send one REST request using an owned or borrowed connection pool.""" + async with AsyncRESTClient(api_key, session=session) as client: + return await client.request( + Route(method, path), + params=params, + json=json, + timeout=timeout, + max_retries=max_retries, + max_rate_limit_wait=max_rate_limit_wait, + user_agent=user_agent, + ) + + async def run_rest_paginated_request_async( path: str, collection: str, @@ -244,7 +292,7 @@ async def run_rest_paginated_request_async( params = {} seen_cursors = set() query = f"GET {path}" - async with aiohttp.ClientSession() as session: + async with HTTPClient() as client: while True: for attempt in range(4): try: @@ -253,7 +301,7 @@ async def run_rest_paginated_request_async( path, api_key=api_key, params=params, - session=session, + session=client.session, user_agent=user_agent, ) break diff --git a/runpod/api/routes.py b/runpod/api/routes.py new file mode 100644 index 000000000..77e9309d1 --- /dev/null +++ b/runpod/api/routes.py @@ -0,0 +1,82 @@ +"""route templates and service origins.""" + +import re +from urllib.parse import quote, urlsplit, urlunsplit + +from runpod._hosts import ( + api_base_url as api_base_url, + endpoint_base_url as _endpoint_base_url, + host_api_base_url as host_api_base_url, + proxy_url, +) + + +def endpoint_base_url(endpoint_id: str | None = None) -> str: + base = _endpoint_base_url() + if endpoint_id is None: + return base + return Route("GET", "/{endpoint_id}", endpoint_id=endpoint_id).url(base) + + +def _host_label(value: str) -> str: + if not re.fullmatch(r"[A-Za-z0-9_-]+", value): + raise ValueError("invalid resource id for a service hostname") + return value + + +def load_balancer_base_url(endpoint_id: str) -> str: + base = urlsplit(endpoint_base_url()) + if base.scheme not in {"http", "https"} or not base.netloc or base.username: + raise ValueError("invalid endpoint base URL") + return urlunsplit( + (base.scheme, f"{_host_label(endpoint_id)}.{base.netloc}", "", "", "") + ) + + +def pod_proxy_base_url(pod_id: str, port: int) -> str: + if isinstance(port, bool) or not isinstance(port, int) or not 1 <= port <= 65535: + raise ValueError("invalid pod proxy port") + return proxy_url(_host_label(pod_id), port) + + +class Route: + """an HTTP method and a path template with escaped parameters.""" + + def __init__(self, method: str, path: str, **parameters): + self.method = method.upper() + self.path = path + self.parameters = parameters + + @property + def resolved_path(self) -> str: + parameters = {} + for name, value in self.parameters.items(): + encoded = quote(str(value), safe="") + parameters[name] = ( + encoded.replace(".", "%2E") if encoded in {".", ".."} else encoded + ) + return self.path.format_map(parameters) + + def url(self, base_url: str | None = None) -> str: + base_url = api_base_url() if base_url is None else base_url + base = urlsplit(base_url) + if base.scheme not in {"http", "https"} or not base.netloc or base.username: + raise ValueError( + "base URL must be an HTTP origin without embedded credentials" + ) + path = self.resolved_path + if not path: + return base_url + parsed = urlsplit(path) + if parsed.scheme or parsed.netloc or parsed.fragment or path.startswith("//"): + raise ValueError("route paths must be relative to their service") + if any(part in {".", ".."} for part in parsed.path.split("/")): + raise ValueError("route paths must not traverse parent directories") + if base.query or base.fragment: + raise ValueError("a service base URL cannot contain a query or fragment") + resolved = quote( + f"{base.path.rstrip('/')}/{parsed.path.lstrip('/')}", + safe="/%:@!$&'()*+,;=-._~", + ) + query = quote(parsed.query, safe="/%?:@!$&'()*+,;=-._~") + return urlunsplit((base.scheme, base.netloc, resolved, query, "")) diff --git a/runpod/apps/api.py b/runpod/apps/api.py index 08ec22f1d..ec6f3b097 100644 --- a/runpod/apps/api.py +++ b/runpod/apps/api.py @@ -1,7 +1,7 @@ """control-plane calls for app provisioning. rest handles equivalent resource operations; graphql handles flash lifecycle, -auth, secrets, task provisioning, and endpoint capabilities +secrets, task provisioning, and endpoint capabilities absent from rest. management verbs for the wider sdk stay in runpod.api.ctl_commands. """ @@ -11,11 +11,12 @@ from ..api.ctl_commands import _cpu_config, _path_segment, _split_values from ..api.graphql import run_graphql_query_async +from ..api.http import HTTPClient from ..api.mutations import apps as app_mutations from ..api.queries import apps as app_queries -from ..api.queries import user as user_queries from ..api.rest import run_rest_paginated_request_async, run_rest_request_async -from ..error import AuthenticationError, QueryError +from ..api.routes import Route +from ..error import QueryError from ..user_agent import APPS_USER_AGENT from .errors import AppHTTPError from .utils.http import raise_for_status @@ -613,32 +614,6 @@ async def delete_environment(self, environment_id: str) -> bool: data = await self._execute(mutation, {"flashEnvironmentId": environment_id}) return bool(data.get("deleteFlashEnvironment")) - async def create_auth_request(self) -> Dict[str, Any]: - """open a browser-approval auth request; no credentials needed.""" - mutation = app_mutations.MUTATION_CREATE_FLASH_AUTH_REQUEST - data = await self._execute(mutation, anonymous=True) - return data.get("createFlashAuthRequest") or {} - - async def get_auth_request_status(self, request_id: str) -> Dict[str, Any]: - query = app_queries.QUERY_FLASH_AUTH_REQUEST_STATUS - data = await self._execute( - query, {"flashAuthRequestId": request_id}, anonymous=True - ) - return data.get("flashAuthRequestStatus") or {} - - async def verify_api_key(self, api_key: str) -> bool: - """true when api_key authenticates; transport failures still raise.""" - try: - response = await run_graphql_query_async( - user_queries.QUERY_USER, - api_key=api_key, - headers={"User-Agent": APPS_USER_AGENT}, - ) - except (AuthenticationError, QueryError): - return False - myself = (response.get("data") or {}).get("myself") or {} - return bool(myself.get("id")) - async def prepare_artifact_upload( self, app_id: str, tarball_size: int ) -> Dict[str, Any]: @@ -711,24 +686,25 @@ async def _reader(): yield chunk attempts = 4 - for attempt in range(attempts): - try: - await self._put_tarball(upload_url, _reader(), total, timeout) - return - except (AppHTTPError, aiohttp.ClientError, OSError): - if attempt == attempts - 1: - raise - await asyncio.sleep(2**attempt) - - async def _put_tarball(self, upload_url, reader, total, timeout) -> None: - async with aiohttp.ClientSession(timeout=timeout) as session: - async with session.put( - upload_url, - data=reader, - headers={ - "User-Agent": APPS_USER_AGENT, - "Content-Type": "application/gzip", - "Content-Length": str(total), - }, - ) as resp: - await raise_for_status(resp) + async with HTTPClient(base_url=upload_url) as client: + for attempt in range(attempts): + try: + await self._put_tarball(client, _reader(), total, timeout) + return + except (AppHTTPError, aiohttp.ClientError, OSError): + if attempt == attempts - 1: + raise + await asyncio.sleep(2**attempt) + + async def _put_tarball(self, client, reader, total, timeout) -> None: + async with client.stream( + Route("PUT", ""), + timeout=timeout, + data=reader, + headers={ + "User-Agent": APPS_USER_AGENT, + "Content-Type": "application/gzip", + "Content-Length": str(total), + }, + ) as resp: + await raise_for_status(resp) diff --git a/runpod/apps/logs.py b/runpod/apps/logs.py index 3c8d32f41..e08ddaa43 100644 --- a/runpod/apps/logs.py +++ b/runpod/apps/logs.py @@ -6,18 +6,15 @@ import asyncio import json -import os from typing import Any, AsyncIterator, Callable, Dict, List, Optional import aiohttp -from ..api.ctl_commands import _path_segment -from ..api.rest import _build_url +from ..api.http import HTTPClient +from ..api.routes import Route, host_api_base_url from ..user_agent import APPS_USER_AGENT from .utils.http import raise_for_status -HAPI_BASE = os.environ.get("RUNPOD_HAPI_URL", "https://hapi.runpod.net") - STREAM_TIMEOUT_SECONDS = 3600.0 @@ -34,14 +31,14 @@ async def pod_logs( timeout: float = 30.0, ) -> Dict[str, List[str]]: """snapshot of a pod's logs: {"container": [...], "system": [...]}.""" - url = f"{HAPI_BASE}/v1/pod/{pod_id}/logs" - client_timeout = aiohttp.ClientTimeout(total=timeout) - async with aiohttp.ClientSession(timeout=client_timeout) as session: - async with session.get( - url, params={"type": log_type}, headers=_headers() - ) as resp: - await raise_for_status(resp) - data = await resp.json() + async with HTTPClient(base_url=host_api_base_url()).stream( + Route("GET", "/v1/pod/{pod_id}/logs", pod_id=pod_id), + params={"type": log_type}, + headers=_headers(), + timeout=timeout, + ) as resp: + await raise_for_status(resp) + data = await resp.json() return {k: v or [] for k, v in data.items()} @@ -66,18 +63,21 @@ async def stream_pod_logs( measured only after the response headers have been received. """ params: Dict[str, Any] = {"tail": str(tail)} + base_url = None if log_type == "all": - url = f"{HAPI_BASE}/v1/pod/{_path_segment(pod_id)}/logs" + base_url = host_api_base_url() + route = Route("GET", "/v1/pod/{pod_id}/logs", pod_id=pod_id) params.update(stream="true", type=log_type) else: if endpoint_id is None: - path = f"/v2/pods/{_path_segment(pod_id)}/logs" + route = Route("GET", "/v2/pods/{pod_id}/logs", pod_id=pod_id) else: - path = ( - f"/v2/serverless/{_path_segment(endpoint_id)}" - f"/workers/{_path_segment(pod_id)}/logs" + route = Route( + "GET", + "/v2/serverless/{endpoint_id}/workers/{pod_id}/logs", + endpoint_id=endpoint_id, + pod_id=pod_id, ) - url = _build_url(path) if log_type: params["source"] = log_type if since: @@ -87,8 +87,10 @@ async def stream_pod_logs( headers["Last-Event-ID"] = last_event_id client_timeout = aiohttp.ClientTimeout(total=STREAM_TIMEOUT_SECONDS, sock_read=60) - async with aiohttp.ClientSession(timeout=client_timeout) as session: - async with session.get(url, params=params, headers=headers) as resp: + async with HTTPClient(base_url=base_url) as client: + async with client.stream( + route, params=params, headers=headers, timeout=client_timeout + ) as resp: await raise_for_status(resp) event_id = None data = [] diff --git a/runpod/apps/targets.py b/runpod/apps/targets.py index 97d941243..9ce17d172 100644 --- a/runpod/apps/targets.py +++ b/runpod/apps/targets.py @@ -13,7 +13,8 @@ import aiohttp -from .._hosts import endpoint_domain +from ..api.http import HTTPClient +from ..api.routes import Route, endpoint_base_url, load_balancer_base_url from ..user_agent import APPS_USER_AGENT from .errors import AppHTTPError, EndpointNotFound, RemoteExecutionError from .protocol import FORMAT_JSON, FunctionRequest @@ -22,7 +23,6 @@ from .utils.events import emit from .utils.http import raise_for_status from .utils.network import api_key as _api_key -from .utils.network import endpoint_url_base as _endpoint_url_base # the sentinel pseudo-endpoint id; ai-api resolves the real endpoint from # the X-Flash-App / X-Flash-Environment / X-Flash-Endpoint headers. @@ -34,11 +34,6 @@ FINAL_STATUSES = frozenset({"COMPLETED", "FAILED", "CANCELLED", "TIMED_OUT"}) -def _lb_domain() -> str: - """host portion of the data-plane base url, for lb subdomain urls.""" - return endpoint_domain() - - def _headers(extra: Optional[Dict[str, str]] = None) -> Dict[str, str]: from .utils.network import runtime_headers @@ -232,20 +227,19 @@ async def _request_json( require_json_value(payload, "remote request body must be JSON-serializable") retry_transient = method.upper() in {"GET", "HEAD", "OPTIONS"} - client_timeout = aiohttp.ClientTimeout(total=timeout) last_exc: Optional[Exception] = None attempts = ( JOB_PROPAGATION_ATTEMPTS if retry_not_found else RETRY_ATTEMPTS if retry_transient else 1 ) - for attempt in range(attempts): - if attempt: - await asyncio.sleep(RETRY_BASE_DELAY * (2 ** (attempt - 1))) - try: - async with aiohttp.ClientSession(timeout=client_timeout) as session: - async with session.request( - method, url, json=payload, headers=headers + async with HTTPClient(base_url=url) as client: + for attempt in range(attempts): + if attempt: + await asyncio.sleep(RETRY_BASE_DELAY * (2 ** (attempt - 1))) + try: + async with client.stream( + Route(method, ""), json=payload, headers=headers, timeout=timeout ) as resp: if resp.status == 404 and job_id is None: last_exc = EndpointNotFound(app_name, resource_name) @@ -254,18 +248,18 @@ async def _request_json( raise last_exc await raise_for_status(resp, job_id=job_id) return await resp.json() - except AppHTTPError as exc: - if (exc.status == 404 and retry_not_found) or ( - exc.status in RETRYABLE_STATUSES and retry_transient - ): + except AppHTTPError as exc: + if (exc.status == 404 and retry_not_found) or ( + exc.status in RETRYABLE_STATUSES and retry_transient + ): + last_exc = exc + continue + raise + except (aiohttp.ClientConnectionError, asyncio.TimeoutError) as exc: + if not retry_transient: + raise last_exc = exc continue - raise - except (aiohttp.ClientConnectionError, asyncio.TimeoutError) as exc: - if not retry_transient: - raise - last_exc = exc - continue if last_exc is None: # pragma: no cover - loop always runs once raise RuntimeError("request retry loop exited cleanly") raise last_exc @@ -352,7 +346,7 @@ async def _wait_terminal( await asyncio.sleep(interval) interval = min(interval * 1.5, max_interval) data = await _get_json( - f"{base_url}/status/{job_id}", + Route("GET", "/status/{job_id}", job_id=job_id).url(base_url), headers, 30.0, app_name=app_name, @@ -389,7 +383,7 @@ def __init__( @property def base_url(self) -> str: - return f"{_endpoint_url_base()}/{self.endpoint_id}" + return endpoint_base_url(self.endpoint_id) async def _call( self, @@ -397,10 +391,12 @@ async def _call( path: str, payload: Any = None, timeout: float = DEFAULT_TIMEOUT_SECONDS, + *, + job_id: Optional[str] = None, ) -> Dict[str, Any]: return await _request_json( method, - f"{self.base_url}/{path}", + Route(method, path).url(self.base_url), self._headers(), timeout, payload=payload, @@ -409,7 +405,7 @@ async def _call( retry_not_found=path.startswith( ("status/", "stream/", "cancel/", "retry/") ), - job_id=path[len("status/") :] if path.startswith("status/") else None, + job_id=job_id, ) async def run( @@ -439,13 +435,20 @@ async def invoke( ) async def status(self, job_id: str) -> Dict[str, Any]: - return await self._call("GET", f"status/{job_id}") + return await self._call( + "GET", Route("GET", "status/{job_id}", job_id=job_id).resolved_path, + job_id=job_id, + ) async def cancel(self, job_id: str) -> Dict[str, Any]: - return await self._call("POST", f"cancel/{job_id}") + return await self._call( + "POST", Route("POST", "cancel/{job_id}", job_id=job_id).resolved_path + ) async def retry(self, job_id: str) -> Dict[str, Any]: - return await self._call("POST", f"retry/{job_id}") + return await self._call( + "POST", Route("POST", "retry/{job_id}", job_id=job_id).resolved_path + ) async def stream(self, job_id: str, *, timeout: float) -> AsyncIterator[Any]: """yield partial outputs from /stream until the job is terminal. @@ -461,7 +464,9 @@ async def stream(self, job_id: str, *, timeout: float) -> AsyncIterator[Any]: raise TimeoutError( f"job {job_id} stream did not complete within {timeout}s" ) - data = await self._call("GET", f"stream/{job_id}") + data = await self._call( + "GET", Route("GET", "stream/{job_id}", job_id=job_id).resolved_path + ) if data.get("status") == "FAILED" or data.get("error"): unwrap_job_output(data) for chunk in data.get("stream") or []: @@ -499,11 +504,14 @@ async def http( ) -> Any: """plain http call through the endpoint's lb subdomain.""" require_json_value(body, "api request body must be JSON-serializable") - url = f"https://{self.endpoint_id}.{_lb_domain()}{path}" - client_timeout = aiohttp.ClientTimeout(total=timeout) - async with aiohttp.ClientSession(timeout=client_timeout) as session: - async with session.request( - method, url, json=body, headers=self._headers() + async with HTTPClient( + base_url=load_balancer_base_url(self.endpoint_id) + ) as client: + async with client.stream( + Route(method, path), + json=body, + headers=self._headers(), + timeout=timeout, ) as resp: if resp.status == 404 and self._app_name: raise EndpointNotFound(self._app_name, self._resource_name) @@ -648,7 +656,9 @@ async def _sync_source(self, timeout: float) -> None: digest = hashlib.sha256(source.encode()).hexdigest() if digest == self._synced_hash: return - url = f"https://{self.endpoint_id}.{_lb_domain()}/_runpod/sync" + url = Route("POST", "/_runpod/sync").url( + load_balancer_base_url(self.endpoint_id) + ) payload: Dict[str, Any] = { "source": source, "resource": self._source_resource, diff --git a/runpod/apps/tasks.py b/runpod/apps/tasks.py index 0f4a4bbbc..b8c2c494f 100644 --- a/runpod/apps/tasks.py +++ b/runpod/apps/tasks.py @@ -19,7 +19,8 @@ import aiohttp -from .._hosts import proxy_url +from ..api.http import HTTPClient +from ..api.routes import Route, pod_proxy_base_url from ..user_agent import APPS_USER_AGENT from .api import AppsApiClient, is_capacity_error from .context import CLEANUP_TIMEOUT @@ -129,7 +130,7 @@ def _device_names(gpu: Optional[List[str]]) -> List[str]: def _proxy_url(pod_id: str) -> str: - return proxy_url(pod_id, TASK_PORT) + return pod_proxy_base_url(pod_id, TASK_PORT) def _pod_input(spec: ResourceSpec, token: str, task_name: str) -> Dict[str, Any]: @@ -212,14 +213,12 @@ def _headers(self) -> Dict[str, str]: async def wait_ready(self, timeout: float = READY_TIMEOUT) -> None: """poll the runner's /ping through the pod proxy until it answers.""" - url = f"{_proxy_url(self.pod_id)}/ping" deadline = time.monotonic() + timeout - async with aiohttp.ClientSession() as session: + async with HTTPClient(base_url=_proxy_url(self.pod_id)) as client: while time.monotonic() < deadline: try: - async with session.get( - url, - timeout=aiohttp.ClientTimeout(total=5), + async with client.stream( + Route("GET", "/ping"), timeout=5, headers={"User-Agent": APPS_USER_AGENT}, ) as resp: if resp.status == 200: @@ -273,15 +272,14 @@ async def _post(self, path: str, request: Dict[str, Any]) -> None: timeout = request.get("timeout") _validate_timeout(timeout) require_json_value(request, "task request body must be JSON-serializable") - url = f"{_proxy_url(self.pod_id)}{path}" attempts = 6 - async with aiohttp.ClientSession() as session: + async with HTTPClient(base_url=_proxy_url(self.pod_id)) as client: for attempt in range(attempts): - async with session.post( - url, + async with client.stream( + Route("POST", path), json=request, headers=self._headers, - timeout=aiohttp.ClientTimeout(total=30), + timeout=30, ) as resp: if resp.status == 404 and attempt < attempts - 1: await asyncio.sleep(2 * (attempt + 1)) @@ -307,15 +305,14 @@ async def poll_result(self) -> Optional[Dict[str, Any]]: retried briefly; a persistent 404 means the pod is gone and surfaces as an error. """ - url = f"{_proxy_url(self.pod_id)}/result" attempts = 6 data: Dict[str, Any] = {} - async with aiohttp.ClientSession() as session: + async with HTTPClient(base_url=_proxy_url(self.pod_id)) as client: for attempt in range(attempts): - async with session.get( - url, + async with client.stream( + Route("GET", "/result"), headers=self._headers, - timeout=aiohttp.ClientTimeout(total=30), + timeout=30, ) as resp: if resp.status == 404 and attempt < attempts - 1: await asyncio.sleep(2 * (attempt + 1)) diff --git a/runpod/apps/utils/network.py b/runpod/apps/utils/network.py index 33f4f7588..bdd1bd220 100644 --- a/runpod/apps/utils/network.py +++ b/runpod/apps/utils/network.py @@ -3,8 +3,8 @@ import os from typing import Any, Dict, Optional -import aiohttp - +from ...api.http import HTTPClient +from ...api.routes import Route, endpoint_base_url from ...user_agent import APPS_USER_AGENT from .http import raise_for_status @@ -55,16 +55,14 @@ def api_key() -> str: def endpoint_url_base() -> str: - import runpod - - return runpod.endpoint_url_base.rstrip("/") + return endpoint_base_url() async def get_json(url: str, headers: Dict[str, str], timeout: float) -> Dict[str, Any]: - client_timeout = aiohttp.ClientTimeout(total=timeout) - async with aiohttp.ClientSession(timeout=client_timeout) as session: - async with session.get( - url, headers={**headers, "User-Agent": APPS_USER_AGENT} - ) as response: - await raise_for_status(response) - return await response.json() + async with HTTPClient(base_url=url).stream( + Route("GET", ""), + headers={**headers, "User-Agent": APPS_USER_AGENT}, + timeout=timeout, + ) as response: + await raise_for_status(response) + return await response.json() diff --git a/runpod/auth/__init__.py b/runpod/auth/__init__.py new file mode 100644 index 000000000..d6238d14d --- /dev/null +++ b/runpod/auth/__init__.py @@ -0,0 +1,28 @@ +"""shared api key selection for the sdk and cli.""" + +import os + + +def load_api_key(profile: str = "default"): + """load the environment key or the selected credential profile.""" + key = os.environ.get("RUNPOD_API_KEY") + if key: + return key + try: + from .credentials import get_credentials + + credentials = get_credentials(profile) + except Exception: + return None + return credentials.get("api_key") if credentials else None + + +def resolve_api_key(api_key=None) -> str: + """select an explicit key or the sdk's configured key.""" + import runpod + from runpod.error import AuthenticationError + + key = api_key or runpod.api_key + if not key: + raise AuthenticationError("No API key provided") + return key diff --git a/runpod/auth/api.py b/runpod/auth/api.py new file mode 100644 index 000000000..3b3fac5be --- /dev/null +++ b/runpod/auth/api.py @@ -0,0 +1,43 @@ +"""account authentication requests and api key verification.""" + +from runpod.api.graphql import run_graphql_query_async +from runpod.api.queries.user import QUERY_USER +from runpod.error import AuthenticationError, QueryError +from runpod.user_agent import APPS_USER_AGENT + + +class AuthApiClient: + """browser approval and credential verification transport.""" + + async def create_auth_request(self) -> dict: + response = await run_graphql_query_async( + """mutation createFlashAuthRequest { + createFlashAuthRequest { id status expiresAt } + }""", + anonymous=True, + headers={"User-Agent": APPS_USER_AGENT}, + ) + return response["data"].get("createFlashAuthRequest") or {} + + async def get_auth_request_status(self, request_id: str) -> dict: + response = await run_graphql_query_async( + """query flashAuthRequestStatus($flashAuthRequestId: String!) { + flashAuthRequestStatus(flashAuthRequestId: $flashAuthRequestId) { + id status + } + }""", + variables={"flashAuthRequestId": request_id}, + anonymous=True, + headers={"User-Agent": APPS_USER_AGENT}, + ) + return response["data"].get("flashAuthRequestStatus") or {} + + async def verify_api_key(self, api_key: str) -> bool: + try: + response = await run_graphql_query_async( + QUERY_USER, api_key=api_key, headers={"User-Agent": APPS_USER_AGENT} + ) + except (AuthenticationError, QueryError): + return False + myself = (response.get("data") or {}).get("myself") or {} + return bool(myself.get("id")) diff --git a/runpod/cli/groups/config/functions.py b/runpod/auth/credentials.py similarity index 96% rename from runpod/cli/groups/config/functions.py rename to runpod/auth/credentials.py index 4e7d3e513..f23d7b860 100644 --- a/runpod/cli/groups/config/functions.py +++ b/runpod/auth/credentials.py @@ -1,9 +1,4 @@ -""" -runpod | cli | config.py - -A collection of functions to set and validate configurations. -Configurations are TOML files located under ~/.runpod/ -""" +"""credential profiles stored in ~/.runpod/config.toml.""" import os import tempfile diff --git a/runpod/apps/auth.py b/runpod/auth/login.py similarity index 89% rename from runpod/apps/auth.py rename to runpod/auth/login.py index d2de9e45c..00f7bc533 100644 --- a/runpod/apps/auth.py +++ b/runpod/auth/login.py @@ -10,20 +10,17 @@ import tempfile from pathlib import Path from typing import Any, Callable, Dict, Optional -from urllib.parse import quote from uuid import uuid4 import aiohttp from runpod._hosts import console_url -from runpod.api.rest import _build_url +from runpod.api.http import HTTPClient +from runpod.api.routes import Route from runpod.user_agent import APPS_USER_AGENT -import aiohttp - -from ..error import QueryError -from .api import AppsApiClient -from .errors import AppError +from ..error import AuthenticationError, QueryError +from .api import AuthApiClient MAX_KEY_ATTEMPTS = 3 @@ -33,7 +30,7 @@ } -class LoginError(AppError): +class LoginError(AuthenticationError): pass @@ -42,15 +39,15 @@ class _VerificationCodeRejected(LoginError): async def _post_authentication_attempt( - session: aiohttp.ClientSession, - path: str, + session: HTTPClient, + route: Route, body: dict, *, creating: bool = False, ) -> dict: try: - async with session.post( - _build_url(path), + async with session.stream( + route, json=body, headers={"Idempotency-Key": str(uuid4())} if creating else {}, allow_redirects=False, @@ -93,7 +90,7 @@ async def _post_authentication_attempt( def pending_agent_login_path(profile: str) -> Path: - from runpod.cli.groups.config.functions import CREDENTIAL_FILE + from runpod.auth.credentials import CREDENTIAL_FILE profile_id = hashlib.sha256(profile.encode("utf-8")).hexdigest() return Path(CREDENTIAL_FILE).parent / f"login-{profile_id}.json" @@ -135,11 +132,9 @@ def load_agent_login(profile: str) -> dict: return attempt -def _agent_session() -> aiohttp.ClientSession: - return aiohttp.ClientSession( - timeout=aiohttp.ClientTimeout(total=30), +def _agent_session() -> HTTPClient: + return HTTPClient( headers={"Accept": "application/json", "User-Agent": APPS_USER_AGENT}, - cookie_jar=aiohttp.DummyCookieJar(), ) @@ -151,12 +146,12 @@ async def start_agent_login(email: str) -> dict: .decode("ascii") .rstrip("=") ) - path = "/v2/signup/authentication-attempts" + route = Route("POST", "/v2/signup/authentication-attempts") async with _agent_session() as session: attempt = await _post_authentication_attempt( session, - path, + route, {"email": email, "keyName": "runpod-cli-agent", "codeChallenge": challenge}, creating=True, ) @@ -164,18 +159,21 @@ async def start_agent_login(email: str) -> dict: if not isinstance(attempt_id, str) or not attempt_id: raise LoginError("auth attempt failed to initialize") - return {"attempt_id": attempt_id, "verifier": verifier, "api_url": _build_url(path)} + return {"attempt_id": attempt_id, "verifier": verifier, "api_url": route.url()} async def verify_agent_login(attempt: dict, code: str) -> str: """exchange a code and its saved verifier for an api key.""" - path = "/v2/signup/authentication-attempts" - if attempt["api_url"] != _build_url(path): + if attempt["api_url"] != Route("POST", "/v2/signup/authentication-attempts").url(): raise LoginError("pending login belongs to a different API. Request a new code") async with _agent_session() as session: result = await _post_authentication_attempt( session, - f"{path}/{quote(attempt['attempt_id'], safe='')}/verify", + Route( + "POST", + "/v2/signup/authentication-attempts/{attempt_id}/verify", + attempt_id=attempt["attempt_id"], + ), {"code": code, "codeVerifier": attempt["verifier"]}, ) credential = result.get("credential") @@ -209,7 +207,7 @@ def auth_url(request_id: str) -> str: return f"{console_url()}/flash/login?request={request_id}" -async def _closed_reason(client: AppsApiClient, request_id: str) -> Optional[str]: +async def _closed_reason(client: AuthApiClient, request_id: str) -> Optional[str]: """why the request can no longer produce a key, or None to keep prompting.""" try: request = await client.get_auth_request_status(request_id) @@ -223,7 +221,7 @@ async def browser_login( prompt_key: Callable[[], str], on_url: Optional[Callable[[str], None]] = None, on_rejected: Optional[Callable[[str], None]] = None, - api: Optional[AppsApiClient] = None, + api: Optional[AuthApiClient] = None, max_attempts: int = MAX_KEY_ATTEMPTS, ) -> str: """run the browser-approval flow and return the pasted api key. @@ -233,7 +231,7 @@ async def browser_login( only to the signed-in approver, so the user pastes it via prompt_key. on_rejected is called with a reason before each re-prompt. """ - client = api or AppsApiClient() + client = api or AuthApiClient() request: Dict[str, Any] = await client.create_auth_request() request_id = request.get("id") diff --git a/runpod/rp_cli/api.py b/runpod/cli/api.py similarity index 94% rename from runpod/rp_cli/api.py rename to runpod/cli/api.py index 05d493f8e..18bfba82c 100644 --- a/runpod/rp_cli/api.py +++ b/runpod/cli/api.py @@ -7,7 +7,7 @@ from runpod import error from runpod.api.rest import run_rest_request -from runpod.rp_cli.compute import ResolutionError +from runpod.cli.compute import ResolutionError def list_all(path: str, collection: str, params: dict | None = None) -> list[dict]: diff --git a/runpod/rp_cli/catalog.py b/runpod/cli/catalog.py similarity index 98% rename from runpod/rp_cli/catalog.py rename to runpod/cli/catalog.py index eed028e75..2bc48111f 100644 --- a/runpod/rp_cli/catalog.py +++ b/runpod/cli/catalog.py @@ -5,9 +5,9 @@ import click from click.core import ParameterSource -from runpod.rp_cli import compute -from runpod.rp_cli.api import api_errors -from runpod.rp_cli.output import json_option, print_json, print_table +from runpod.cli import compute +from runpod.cli.api import api_errors +from runpod.cli.output import json_option, print_json, print_table def _money(value: Optional[float], format_spec: str = ".2f") -> str: diff --git a/runpod/rp_cli/compute.py b/runpod/cli/compute.py similarity index 100% rename from runpod/rp_cli/compute.py rename to runpod/cli/compute.py diff --git a/runpod/rp_cli/console.py b/runpod/cli/console.py similarity index 100% rename from runpod/rp_cli/console.py rename to runpod/cli/console.py diff --git a/runpod/rp_cli/endpoint.py b/runpod/cli/endpoint.py similarity index 99% rename from runpod/rp_cli/endpoint.py rename to runpod/cli/endpoint.py index c27d43a43..a2a30ce60 100644 --- a/runpod/rp_cli/endpoint.py +++ b/runpod/cli/endpoint.py @@ -16,9 +16,9 @@ from runpod.apps.utils.network import api_key from runpod.endpoint import runner from runpod.endpoint.helpers import is_completed -from runpod.rp_cli import compute, console as ui, endpoint_config as config -from runpod.rp_cli.api import api_errors, list_all -from runpod.rp_cli.output import ( +from runpod.cli import compute, console as ui, endpoint_config as config +from runpod.cli.api import api_errors, list_all +from runpod.cli.output import ( completer, confirm, interactive, @@ -988,7 +988,7 @@ def logs(endpoint_id, worker_ids, follow, source, tail, since, as_json): Without --worker, every worker's logs are multiplexed, and with --follow newly created workers are attached automatically. """ - from runpod.rp_cli.logs import show_logs + from runpod.cli.logs import show_logs show_logs( endpoint_id=endpoint_id, diff --git a/runpod/rp_cli/endpoint_config.py b/runpod/cli/endpoint_config.py similarity index 99% rename from runpod/rp_cli/endpoint_config.py rename to runpod/cli/endpoint_config.py index 5a7757479..8d0a7fb5d 100644 --- a/runpod/rp_cli/endpoint_config.py +++ b/runpod/cli/endpoint_config.py @@ -3,8 +3,8 @@ import click -from runpod.rp_cli import compute -from runpod.rp_cli.options import container_fields +from runpod.cli import compute +from runpod.cli.options import container_fields FLASHBOOT = {"off": "OFF", "standard": "FLASHBOOT", "priority": "PRIORITY_FLASHBOOT"} diff --git a/runpod/cli/groups/config/__init__.py b/runpod/cli/groups/config/__init__.py index d9af37604..9de3d7a4c 100644 --- a/runpod/cli/groups/config/__init__.py +++ b/runpod/cli/groups/config/__init__.py @@ -1 +1,7 @@ -""" Config related CLI functions. """ +"""credential imports for runpod-flash.""" + +import sys + +from runpod.auth import credentials as functions + +sys.modules[f"{__name__}.functions"] = functions diff --git a/runpod/rp_cli/logs.py b/runpod/cli/logs.py similarity index 98% rename from runpod/rp_cli/logs.py rename to runpod/cli/logs.py index 9823a6e9b..7d0062e49 100644 --- a/runpod/rp_cli/logs.py +++ b/runpod/cli/logs.py @@ -11,8 +11,8 @@ from runpod.api.rest import run_rest_request from runpod.apps.errors import AppHTTPError from runpod.apps.logs import stream_pod_logs -from runpod.rp_cli import console as ui -from runpod.rp_cli.api import api_errors +from runpod.cli import console as ui +from runpod.cli.api import api_errors SNAPSHOT_IDLE_SECONDS = 3 WORKER_POLL_SECONDS = 5 diff --git a/runpod/rp_cli/main.py b/runpod/cli/main.py similarity index 96% rename from runpod/rp_cli/main.py rename to runpod/cli/main.py index 9c8931393..0835fd719 100644 --- a/runpod/rp_cli/main.py +++ b/runpod/cli/main.py @@ -36,7 +36,7 @@ def cli(ctx): Using an AI agent? Point it to https://docs.runpod.io/agent-setup.md """ if ctx.invoked_subcommand not in _UPDATE_CHECK_EXCLUDED: - from runpod.rp_cli.update import start_background_check + from runpod.cli.update import start_background_check start_background_check() @@ -46,7 +46,7 @@ def cli(ctx): def flash(ctx): """Build, develop, and manage Flash apps.""" if ctx.invoked_subcommand not in _FLASH_UPDATE_CHECK_EXCLUDED: - from runpod.rp_cli.update import start_background_check + from runpod.cli.update import start_background_check start_background_check() @@ -79,7 +79,7 @@ def _app_source(found, project_root: Path) -> str: def init(project_name, force): """Create a new app project (PROJECT_NAME, or '.' for the cwd).""" from runpod.apps.init import create_project, detect_conflicts - from runpod.rp_cli import console as ui + from runpod.cli import console as ui if project_name is None or project_name == ".": project_dir = Path.cwd() @@ -118,8 +118,8 @@ def init(project_name, force): ) def update(version_opt): """Update the runpod package to the latest (or a given) version.""" - from runpod.rp_cli import console as ui - from runpod.rp_cli.update import ( + from runpod.cli import console as ui + from runpod.cli.update import ( compare_versions, current_version, fetch_pypi_metadata, @@ -187,7 +187,7 @@ def deploy(target, env, python_version, exclude, build_only): from runpod.apps.deploy import build_artifact, deploy_app from runpod.apps.discovery import discover_apps, resolve_project - from runpod.rp_cli import console as ui + from runpod.cli import console as ui logging.getLogger("runpod.apps").setLevel(logging.WARNING) @@ -338,7 +338,7 @@ def dev(target, once, entrypoint_selector): ) from runpod.apps.utils.names import dev_endpoint_name from runpod.apps.watch import FileWatcher - from runpod.rp_cli import console as ui + from runpod.cli import console as ui logging.getLogger("runpod.apps").setLevel(logging.WARNING) @@ -676,7 +676,7 @@ def login(no_open, api_key_opt, profile, agent, email, code): deleted after credentials are saved. Treat the code as a secret. Command arguments can appear in shell history and process listings. """ - from runpod.apps.auth import ( + from runpod.auth.login import ( LoginError, browser_login, load_agent_login, @@ -685,8 +685,8 @@ def login(no_open, api_key_opt, profile, agent, email, code): start_agent_login, verify_agent_login, ) - from runpod.cli.groups.config.functions import set_credentials - from runpod.rp_cli import console as ui + from runpod.auth.credentials import set_credentials + from runpod.cli import console as ui if agent and api_key_opt is not None: raise click.UsageError("--agent cannot be combined with --api-key") @@ -786,7 +786,7 @@ def app(): def app_list(): """List all apps and their environments.""" from runpod.apps.manage import list_apps - from runpod.rp_cli import console as ui + from runpod.cli import console as ui try: apps = asyncio.run(list_apps()) @@ -815,7 +815,7 @@ def app_list(): def app_get(app_name): """Show one app with its environments.""" from runpod.apps.manage import get_app - from runpod.rp_cli import console as ui + from runpod.cli import console as ui try: entry = asyncio.run(get_app(app_name)) @@ -841,7 +841,7 @@ def app_get(app_name): def app_delete(app_name, yes): """Delete an app, undeploying every environment in it.""" from runpod.apps.manage import delete_app - from runpod.rp_cli import console as ui + from runpod.cli import console as ui if not yes: click.confirm( @@ -878,7 +878,7 @@ def registry(): def registry_add(name, username, password): """Create a registry credential. Reference it with registry_auth=NAME.""" from runpod.apps.api import AppsApiClient - from runpod.rp_cli import console as ui + from runpod.cli import console as ui if name is None: name = click.prompt("name") @@ -903,7 +903,7 @@ def registry_add(name, username, password): def registry_list(): """List registry credential names.""" from runpod.apps.api import AppsApiClient - from runpod.rp_cli import console as ui + from runpod.cli import console as ui try: creds = asyncio.run(AppsApiClient().list_registry_auths()) @@ -927,7 +927,7 @@ def registry_list(): def registry_delete(name, yes): """Delete a registry credential by name.""" from runpod.apps.api import AppsApiClient - from runpod.rp_cli import console as ui + from runpod.cli import console as ui async def _delete(): client = AppsApiClient() @@ -964,7 +964,7 @@ def secret_add(name, value, description): name and value, `rp secret add NAME` asks for just the value. """ from runpod.apps.api import AppsApiClient - from runpod.rp_cli import console as ui + from runpod.cli import console as ui if name is None: name = click.prompt("name") @@ -985,7 +985,7 @@ def secret_add(name, value, description): def secret_list(): """List secret names (values are never shown).""" from runpod.apps.api import AppsApiClient - from runpod.rp_cli import console as ui + from runpod.cli import console as ui try: secrets = asyncio.run(AppsApiClient().list_secrets()) @@ -1011,7 +1011,7 @@ def secret_list(): def secret_delete(name, yes): """Delete a secret by name.""" from runpod.apps.api import AppsApiClient - from runpod.rp_cli import console as ui + from runpod.cli import console as ui async def _delete(): client = AppsApiClient() @@ -1057,7 +1057,7 @@ def _resolve_app_name(app_name) -> str: def env_list(app_name): """List environments for an app.""" from runpod.apps.manage import get_app - from runpod.rp_cli import console as ui + from runpod.cli import console as ui name = _resolve_app_name(app_name) try: @@ -1089,7 +1089,7 @@ def env_list(app_name): def env_get(env_name, app_name): """Show an environment with its endpoints.""" from runpod.apps.manage import get_environment - from runpod.rp_cli import console as ui + from runpod.cli import console as ui name = _resolve_app_name(app_name) try: @@ -1120,7 +1120,7 @@ def env_add(env_name, app_name): """Create a new environment in an app.""" from runpod.apps.api import AppsApiClient from runpod.apps.manage import get_app - from runpod.rp_cli import console as ui + from runpod.cli import console as ui name = _resolve_app_name(app_name) @@ -1143,7 +1143,7 @@ async def _create(): def env_delete(env_name, app_name, yes): """Undeploy and delete an environment.""" from runpod.apps.manage import undeploy_environment - from runpod.rp_cli import console as ui + from runpod.cli import console as ui name = _resolve_app_name(app_name) if not yes: @@ -1182,7 +1182,7 @@ def undeploy(app_name, env_name, yes): the app and its build history remain. """ from runpod.apps.manage import undeploy_environment - from runpod.rp_cli import console as ui + from runpod.cli import console as ui name = _resolve_app_name(app_name) if not yes: @@ -1213,10 +1213,10 @@ def undeploy(app_name, env_name, yes): def _mount_groups() -> None: from runpod.cli.groups.ssh.commands import ssh_cli - from runpod.rp_cli.catalog import catalog - from runpod.rp_cli.endpoint import endpoint - from runpod.rp_cli.pod import pod - from runpod.rp_cli.volume import volume + from runpod.cli.catalog import catalog + from runpod.cli.endpoint import endpoint + from runpod.cli.pod import pod + from runpod.cli.volume import volume for command in (ssh_cli, pod, catalog, volume, endpoint): cli.add_command(command) diff --git a/runpod/rp_cli/options.py b/runpod/cli/options.py similarity index 95% rename from runpod/rp_cli/options.py rename to runpod/cli/options.py index f9ffe61c8..c0c4c9937 100644 --- a/runpod/rp_cli/options.py +++ b/runpod/cli/options.py @@ -5,8 +5,8 @@ import click -from runpod.rp_cli.api import list_all -from runpod.rp_cli.compute import ResolutionError +from runpod.cli.api import list_all +from runpod.cli.compute import ResolutionError def parse_env(values: Iterable[str]) -> dict[str, str]: diff --git a/runpod/rp_cli/output.py b/runpod/cli/output.py similarity index 97% rename from runpod/rp_cli/output.py rename to runpod/cli/output.py index c715d9904..4bb14444f 100644 --- a/runpod/rp_cli/output.py +++ b/runpod/cli/output.py @@ -43,7 +43,7 @@ def table(rows: Sequence[dict], columns: Sequence[Column]): def print_table(rows: Sequence[dict], columns: Sequence[Column], empty: str) -> None: - from runpod.rp_cli import console as ui + from runpod.cli import console as ui ui.console.print(table(rows, columns) if rows else f"[dim]{empty}[/dim]") @@ -52,7 +52,7 @@ def print_fields(record: dict, fields: Sequence[Column]) -> None: from rich.markup import escape from rich.table import Table - from runpod.rp_cli import console as ui + from runpod.cli import console as ui result = Table.grid(padding=(0, 2)) result.add_column(style="dim", no_wrap=True) diff --git a/runpod/rp_cli/pod.py b/runpod/cli/pod.py similarity index 98% rename from runpod/rp_cli/pod.py rename to runpod/cli/pod.py index 22def6976..caf352446 100644 --- a/runpod/rp_cli/pod.py +++ b/runpod/cli/pod.py @@ -7,10 +7,10 @@ from runpod._hosts import proxy_url from runpod.api.rest import run_rest_request from runpod.cli.groups.pod.commands import sync_pods -from runpod.rp_cli import compute -from runpod.rp_cli.api import api_errors, list_all -from runpod.rp_cli.options import container_fields -from runpod.rp_cli.output import ( +from runpod.cli import compute +from runpod.cli.api import api_errors, list_all +from runpod.cli.options import container_fields +from runpod.cli.output import ( completer, confirm, interactive, @@ -72,7 +72,7 @@ def _say(message: str, as_json: bool, warning: bool = False) -> None: return from rich.markup import escape - from runpod.rp_cli import console as ui + from runpod.cli import console as ui (ui.warn if warning else ui.info)(escape(message)) @@ -166,7 +166,7 @@ def _show(pod: dict, as_json: bool) -> None: def _wait_running(pod_id: str, since: float, previous: Optional[dict] = None) -> dict: - from runpod.rp_cli import console as ui + from runpod.cli import console as ui deadline = time.monotonic() + WAIT_TIMEOUT previous_uptime = ((previous or {}).get("runtime") or {}).get("uptime") or 0 @@ -723,7 +723,7 @@ def restart(pod_id, wait, as_json): @click.option("--yes", "-y", is_flag=True, help="Skip the confirmation prompt.") def terminate(pod_id, yes): """Terminate a pod permanently.""" - from runpod.rp_cli import console as ui + from runpod.cli import console as ui pod_id = _resolve_pod_id(pod_id, "terminate") with api_errors(): @@ -750,7 +750,7 @@ def terminate(pod_id, yes): @json_option def logs(pod_id, follow, tail, source, since, as_json): """Read a pod's container or system logs.""" - from runpod.rp_cli.logs import show_logs + from runpod.cli.logs import show_logs pod_id = _resolve_pod_id(pod_id) show_logs( diff --git a/runpod/rp_cli/update.py b/runpod/cli/update.py similarity index 100% rename from runpod/rp_cli/update.py rename to runpod/cli/update.py diff --git a/runpod/rp_cli/volume.py b/runpod/cli/volume.py similarity index 98% rename from runpod/rp_cli/volume.py rename to runpod/cli/volume.py index bdefc85ea..d87165c97 100644 --- a/runpod/rp_cli/volume.py +++ b/runpod/cli/volume.py @@ -6,9 +6,9 @@ import click from runpod.api.rest import run_rest_request -from runpod.rp_cli import compute, console as ui -from runpod.rp_cli.api import api_errors, list_all -from runpod.rp_cli.output import ( +from runpod.cli import compute, console as ui +from runpod.cli.api import api_errors, list_all +from runpod.cli.output import ( completer, confirm, json_option, @@ -461,8 +461,8 @@ def _ensure_logged_in(ctx) -> None: needs one.""" import runpod import runpod.network_volume_transfer as nvt - from runpod.cli.groups.config.functions import get_credentials - from runpod.rp_cli.main import login + from runpod.auth.credentials import get_credentials + from runpod.cli.main import login if runpod.api_key: return @@ -513,7 +513,7 @@ def _prompt_s3_keys(): """ask for the s3 keys, offering to save them for next time.""" import runpod import runpod.network_volume_transfer as nvt - from runpod.cli.groups.config.functions import set_s3_keys + from runpod.auth.credentials import set_s3_keys if not _interactive(): raise click.ClickException(_missing_keys_message()) diff --git a/runpod/endpoint/asyncio/asyncio_runner.py b/runpod/endpoint/asyncio/asyncio_runner.py index e76ad1971..308f0127c 100644 --- a/runpod/endpoint/asyncio/asyncio_runner.py +++ b/runpod/endpoint/asyncio/asyncio_runner.py @@ -5,6 +5,8 @@ import asyncio from typing import Any, Dict, Optional +from runpod.api.http import HTTPClient +from runpod.api.routes import Route, endpoint_base_url from runpod.endpoint.helpers import FINAL_STATES, is_completed, raise_for_job_state from runpod.http_client import ClientSession @@ -22,14 +24,10 @@ def __init__(self, endpoint_id: str, job_id: str, session: ClientSession, header session: The aiohttp ClientSession. headers: Headers to use for requests. """ - from runpod import ( # pylint: disable=import-outside-toplevel,cyclic-import - endpoint_url_base, - ) - self.endpoint_id = endpoint_id self.job_id = job_id self.session = session - self.endpoint_url_base = endpoint_url_base + self.endpoint_url_base = endpoint_base_url() self.headers = headers self.job_status = None @@ -42,11 +40,18 @@ async def _fetch_job(self, source: str = "status") -> Dict[str, Any]: Args: source: The URL source path of the job status. """ - status_url = ( - f"{self.endpoint_url_base}/{self.endpoint_id}/{source}/{self.job_id}" + route = Route( + "GET", + "{endpoint_id}/{source}/{job_id}", + endpoint_id=self.endpoint_id, + source=source, + job_id=self.job_id, ) - job_state = await self.session.get(status_url, headers=self.headers) - job_state = await job_state.json() + client = HTTPClient(self.endpoint_url_base, session=self.session) + async with client.stream( + route, headers=self.headers, timeout=self.session.timeout + ) as response: + job_state = await response.json() if is_completed(job_state["status"]): self.job_status = job_state["status"] @@ -117,8 +122,16 @@ async def cancel(self) -> dict: Returns: Output of cancel operation """ - cancel_url = f"{self.endpoint_url_base}/{self.endpoint_id}/cancel/{self.job_id}" - async with self.session.post(cancel_url, headers=self.headers) as resp: + route = Route( + "POST", + "{endpoint_id}/cancel/{job_id}", + endpoint_id=self.endpoint_id, + job_id=self.job_id, + ) + client = HTTPClient(self.endpoint_url_base, session=self.session) + async with client.stream( + route, headers=self.headers, timeout=self.session.timeout + ) as resp: return await resp.json() @@ -137,13 +150,14 @@ def __init__(self, endpoint_id: str, session: ClientSession, """ from runpod import ( # pylint: disable=import-outside-toplevel api_key as global_api_key, - endpoint_url_base, ) self.endpoint_id = endpoint_id self.session = session - self.endpoint_url_base = endpoint_url_base - self.endpoint_url = f"{endpoint_url_base}/{self.endpoint_id}/run" + self.endpoint_url_base = endpoint_base_url() + self.endpoint_url = Route( + "POST", "{endpoint_id}/run", endpoint_id=self.endpoint_id + ).url(self.endpoint_url_base) # Store instance API key for future requests self.api_key = api_key or global_api_key @@ -166,8 +180,12 @@ async def run(self, endpoint_input: dict) -> Job: Returns: Newly created job """ - async with self.session.post( - self.endpoint_url, headers=self.headers, json={"input": endpoint_input} + client = HTTPClient(self.endpoint_url_base, session=self.session) + async with client.stream( + Route("POST", "{endpoint_id}/run", endpoint_id=self.endpoint_id), + headers=self.headers, + json={"input": endpoint_input}, + timeout=self.session.timeout, ) as resp: json_resp = await resp.json() @@ -183,9 +201,12 @@ async def health(self) -> dict: Returns: Health of endpoint """ - health_url = f"{self.endpoint_url_base}/{self.endpoint_id}/health" - - async with self.session.get(health_url, headers=self.headers) as resp: + client = HTTPClient(self.endpoint_url_base, session=self.session) + async with client.stream( + Route("GET", "{endpoint_id}/health", endpoint_id=self.endpoint_id), + headers=self.headers, + timeout=self.session.timeout, + ) as resp: return await resp.json() async def purge_queue(self) -> dict: @@ -195,7 +216,10 @@ async def purge_queue(self) -> dict: Returns: Purge status """ - purge_url = f"{self.endpoint_url_base}/{self.endpoint_id}/purge-queue" - - async with self.session.post(purge_url, headers=self.headers) as resp: + client = HTTPClient(self.endpoint_url_base, session=self.session) + async with client.stream( + Route("POST", "{endpoint_id}/purge-queue", endpoint_id=self.endpoint_id), + headers=self.headers, + timeout=self.session.timeout, + ) as resp: return await resp.json() diff --git a/runpod/endpoint/runner.py b/runpod/endpoint/runner.py index 4bf6650b7..814b726cc 100644 --- a/runpod/endpoint/runner.py +++ b/runpod/endpoint/runner.py @@ -8,6 +8,8 @@ import requests from requests.adapters import HTTPAdapter, Retry +from runpod.api.http import SyncHTTPClient +from runpod.api.routes import Route, endpoint_base_url from runpod.endpoint.helpers import ( API_KEY_NOT_SET_MSG, FINAL_STATES, @@ -35,7 +37,6 @@ def __init__(self, api_key: Optional[str] = None): """ from runpod import ( # pylint: disable=import-outside-toplevel, cyclic-import api_key as global_api_key, - endpoint_url_base, ) # Use provided api_key or fall back to global @@ -53,7 +54,17 @@ def __init__(self, api_key: Optional[str] = None): "Authorization": f"Bearer {self.api_key}", } - self.endpoint_url_base = endpoint_url_base + self.endpoint_url_base = endpoint_base_url() + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + def close(self): + """Close the client's connection pool.""" + self.rp_session.close() def _request( self, method: str, endpoint: str, data: Optional[dict] = None, @@ -75,16 +86,15 @@ def _request( RuntimeError: If the response returns a 401 Unauthorized status. requests.HTTPError: If the response contains an unsuccessful status code. """ - url = f"{self.endpoint_url_base}/{endpoint}" - response = self.rp_session.request( - method, url, headers=self.headers, json=data, timeout=timeout - ) + client = SyncHTTPClient(self.endpoint_url_base, session=self.rp_session) + with client.stream( + Route(method, endpoint), headers=self.headers, json=data, timeout=timeout + ) as response: + if response.status_code == 401: + raise RuntimeError(UNAUTHORIZED_MSG) - if response.status_code == 401: - raise RuntimeError(UNAUTHORIZED_MSG) - - response.raise_for_status() - return response.json() + response.raise_for_status() + return response.json() def post(self, endpoint: str, data: dict, timeout: int = 10): """Post to the endpoint.""" @@ -120,7 +130,13 @@ def __init__(self, endpoint_id: str, job_id: str, client: RunPodClient): def _fetch_job(self, source: str = "status") -> Dict[str, Any]: """Returns the raw json of the status, raises an exception if invalid""" - status_url = f"{self.endpoint_id}/{source}/{self.job_id}" + status_url = Route( + "GET", + "{endpoint_id}/{source}/{job_id}", + endpoint_id=self.endpoint_id, + source=source, + job_id=self.job_id, + ).resolved_path job_state = self.rp_client.get(endpoint=status_url) if is_completed(job_state["status"]): @@ -189,7 +205,12 @@ def cancel(self, timeout: int = 3) -> Any: timeout: The number of seconds to wait for the server to respond before giving up. """ return self.rp_client.post( - f"{self.endpoint_id}/cancel/{self.job_id}", + Route( + "POST", + "{endpoint_id}/cancel/{job_id}", + endpoint_id=self.endpoint_id, + job_id=self.job_id, + ).resolved_path, data=None, timeout=timeout ) @@ -218,6 +239,16 @@ def __init__(self, endpoint_id: str, api_key: Optional[str] = None): self.endpoint_id = endpoint_id self.rp_client = RunPodClient(api_key=api_key) + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + def close(self): + """Close the endpoint's connection pool after its jobs finish.""" + self.rp_client.close() + def run(self, request_input: Dict[str, Any]) -> Job: """ Run the endpoint with the given input. @@ -232,7 +263,7 @@ def run(self, request_input: Dict[str, Any]) -> Job: request_input = {"input": request_input} job_request = self.rp_client.post( - f"{self.endpoint_id}/run", + Route("POST", "{endpoint_id}/run", endpoint_id=self.endpoint_id).resolved_path, request_input ) return Job(self.endpoint_id, job_request["id"], self.rp_client) @@ -255,7 +286,9 @@ def run_sync( request_input = {"input": request_input} job_request = self.rp_client.post( - f"{self.endpoint_id}/runsync", + Route( + "POST", "{endpoint_id}/runsync", endpoint_id=self.endpoint_id + ).resolved_path, request_input, timeout=timeout ) @@ -278,7 +311,7 @@ def health(self, timeout: int = 3) -> Dict[str, Any]: timeout: The number of seconds to wait for the server to respond before giving up. """ return self.rp_client.get( - f"{self.endpoint_id}/health", + Route("GET", "{endpoint_id}/health", endpoint_id=self.endpoint_id).resolved_path, timeout=timeout ) @@ -290,7 +323,9 @@ def purge_queue(self, timeout: int = 3) -> Dict[str, Any]: timeout: The number of seconds to wait for the server to respond before giving up. """ return self.rp_client.post( - f"{self.endpoint_id}/purge-queue", + Route( + "POST", "{endpoint_id}/purge-queue", endpoint_id=self.endpoint_id + ).resolved_path, data=None, timeout=timeout ) diff --git a/runpod/http_client.py b/runpod/http_client.py index d6455f00a..a194dc342 100644 --- a/runpod/http_client.py +++ b/runpod/http_client.py @@ -7,7 +7,7 @@ import requests from aiohttp import ClientSession, ClientTimeout, TCPConnector, ClientResponseError -from .cli.groups.config.functions import get_credentials +from .auth.credentials import get_credentials from .user_agent import USER_AGENT diff --git a/runpod/network_volume_transfer.py b/runpod/network_volume_transfer.py index c55a37822..89cf73812 100644 --- a/runpod/network_volume_transfer.py +++ b/runpod/network_volume_transfer.py @@ -894,7 +894,7 @@ def _resolve_volume(reference: str, *, user_agent: str = USER_AGENT) -> Tuple[st def saved_s3_keys() -> Tuple[Optional[str], Optional[str]]: """the s3 keys saved in ~/.runpod/config.toml for the current profile.""" from runpod import profile # pylint: disable=import-outside-toplevel - from runpod.cli.groups.config.functions import ( # pylint: disable=import-outside-toplevel + from runpod.auth.credentials import ( # pylint: disable=import-outside-toplevel get_credentials, ) diff --git a/runpod/rp_cli/__init__.py b/runpod/rp_cli/__init__.py deleted file mode 100644 index de9fc580d..000000000 --- a/runpod/rp_cli/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""the `rp` command line interface.""" diff --git a/setup.py b/setup.py index 7f8a076e8..60d3012f6 100644 --- a/setup.py +++ b/setup.py @@ -66,8 +66,8 @@ }, entry_points={ "console_scripts": [ - "runpod = runpod.rp_cli.main:run", - "rp = runpod.rp_cli.main:run", + "runpod = runpod.cli.main:run", + "rp = runpod.cli.main:run", ] }, keywords=[ diff --git a/tests/test_api/test_http.py b/tests/test_api/test_http.py new file mode 100644 index 000000000..8c74eb127 --- /dev/null +++ b/tests/test_api/test_http.py @@ -0,0 +1,242 @@ +"""shared transport ownership, route resolution, and credential boundaries.""" + +import asyncio +import json +import threading +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + +import aiohttp +import pytest +import requests + +import runpod +from runpod.api.http import HTTPClient, SyncHTTPClient +from runpod.api.rest import AsyncRESTClient, RESTClient +from runpod.api.routes import ( + Route, + endpoint_base_url, + host_api_base_url, + load_balancer_base_url, + pod_proxy_base_url, +) + + +@pytest.fixture +def http_server(): + state = {"requests": [], "status": 200, "body": b'{"ok":true}'} + + class Handler(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + + def do_GET(self): + body = self.rfile.read(int(self.headers.get("Content-Length", 0))) + state["requests"].append( + (self.command, self.path, dict(self.headers), body, self.client_address) + ) + payload = state["body"] + self.send_response(state["status"]) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(payload))) + self.send_header("Set-Cookie", "session=should-not-be-replayed") + self.send_header("Location", "/redirect-target") + self.end_headers() + self.wfile.write(payload) + + do_POST = do_PUT = do_GET + + def log_message(self, *args): + pass + + server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + worker = threading.Thread(target=server.serve_forever, daemon=True) + worker.start() + try: + yield f"http://127.0.0.1:{server.server_port}/prefix/", state + finally: + server.shutdown() + server.server_close() + worker.join() + + +def test_route_encodes_parameters_and_preserves_service_prefix(): + route = Route("get", "/v2/pods/{pod_id}", pod_id="id/with ?#%") + assert route.method == "GET" + assert route.url("https://api.example/base/") == ( + "https://api.example/base/v2/pods/id%2Fwith%20%3F%23%25" + ) + + +@pytest.mark.parametrize( + "path", ["https://other.example/x", "//other.example/x", "../x", "/x#secret"] +) +def test_route_cannot_override_service_origin(path): + with pytest.raises(ValueError): + Route("GET", path).url("https://api.example/prefix") + + +@pytest.mark.parametrize( + "base", ["file:///tmp/data", "https://user:password@example.com", "relative"] +) +def test_route_requires_http_origin_without_credentials(base): + with pytest.raises(ValueError): + Route("GET", "/v2/pods").url(base) + + +def test_signed_upload_url_is_preserved_exactly(): + url = "https://storage.example/artifact?signature=a%2Fb&expires=123" + assert Route("PUT", "").url(url) == url + with pytest.raises(ValueError): + Route("PUT", "/another").url(url) + + +def test_route_encodes_literal_spaces_without_requoting_parameters(): + assert ( + Route("GET", "/hello world/{value}?q=a b", value="a/b").url( + "https://api.example/base path/" + ) + == "https://api.example/base%20path/hello%20world/a%2Fb?q=a%20b" + ) + + +def test_service_bases_respect_configuration(monkeypatch): + monkeypatch.setenv("RUNPOD_API_BASE_URL", "http://control.example/prefix/") + monkeypatch.setenv("RUNPOD_HAPI_URL", "http://logs.example/prefix/") + monkeypatch.setattr(runpod, "endpoint_url_base", "http://worker.example:8080/v2/") + assert Route("POST", "/graphql").url() == "http://control.example/prefix/graphql" + assert host_api_base_url() == "http://logs.example/prefix" + assert ( + endpoint_base_url("endpoint/id") + == "http://worker.example:8080/v2/endpoint%2Fid" + ) + assert ( + load_balancer_base_url("endpoint-id") + == "http://endpoint-id.worker.example:8080" + ) + assert pod_proxy_base_url("pod-id", 8080) == "https://pod-id-8080.proxy.runpod.net" + + +@pytest.mark.parametrize( + "resource_id", ["other.example/", "id@evil.example", "id:123", ""] +) +def test_resource_hostnames_reject_url_components(resource_id): + with pytest.raises(ValueError): + load_balancer_base_url(resource_id) + with pytest.raises(ValueError): + pod_proxy_base_url(resource_id, 8080) + + +async def test_async_client_reuses_and_closes_owned_session(http_server): + base, state = http_server + client = HTTPClient(base) + async with client: + session = client.session + assert await client.request(Route("GET", "/first")) == {"ok": True} + assert await client.request(Route("GET", "/second")) == {"ok": True} + assert client.session is session + assert not session.closed + assert session.closed + assert client.session is None + assert state["requests"][0][4] == state["requests"][1][4] + assert all("Cookie" not in request[2] for request in state["requests"]) + + +async def test_borrowed_async_session_is_not_closed(http_server): + base, state = http_server + async with aiohttp.ClientSession(headers={"User-Agent": "caller-agent"}) as session: + async with HTTPClient(base, session=session) as client: + assert await client.request(Route("GET", "/pods")) == {"ok": True} + assert not session.closed + assert state["requests"][0][2]["User-Agent"] == "caller-agent" + + +async def test_concurrent_one_shot_calls_have_independent_lifetimes(http_server): + base, state = http_server + client = HTTPClient(base) + results = await asyncio.gather( + *(client.request(Route("GET", "/{index}", index=index)) for index in range(4)) + ) + assert results == [{"ok": True}] * 4 + assert len(state["requests"]) == 4 + assert client.session is None + + +async def test_raw_transport_never_reads_account_credentials(http_server, monkeypatch): + base, state = http_server + monkeypatch.setattr(runpod, "api_key", "account-secret") + monkeypatch.setenv("RUNPOD_API_KEY", "environment-secret") + client = HTTPClient(base) + await client.request(Route("GET", "/anonymous")) + await client.request( + Route("GET", "/worker"), headers={"Authorization": "Bearer task-token"} + ) + assert "Authorization" not in state["requests"][0][2] + assert state["requests"][1][2]["Authorization"] == "Bearer task-token" + + +async def test_redirect_is_not_followed_with_credentials(http_server): + base, state = http_server + state["status"] = 302 + with pytest.raises(aiohttp.ClientResponseError) as caught: + await HTTPClient(base).request( + Route("GET", "/start"), headers={"Authorization": "Bearer private-key"} + ) + assert caught.value.status == 302 + assert len(state["requests"]) == 1 + + +async def test_response_decoding_and_streaming_errors(http_server): + base, state = http_server + async with HTTPClient(base) as client: + state.update(status=204, body=b"") + assert await client.request(Route("GET", "/empty")) is None + state.update(status=200, body=b"plain text") + assert ( + await client.request(Route("GET", "/text"), response_type="text") + == "plain text" + ) + state.update(status=403, body=b'{"detail":"denied"}') + async with client.stream(Route("GET", "/error")) as response: + assert response.status == 403 + assert await response.json() == {"detail": "denied"} + with pytest.raises(aiohttp.ClientResponseError): + await client.request(Route("GET", "/error")) + + +async def test_async_rest_client_reuses_pool_and_explicit_key(http_server, monkeypatch): + base, state = http_server + monkeypatch.setattr(runpod, "api_key", "wrong-key") + async with AsyncRESTClient("right-key", base_url=base) as client: + session = client.session + await client.request(Route("GET", "/v2/pods")) + await client.request(Route("POST", "/v2/pods"), json={"name": "pod"}) + assert client.session is session + assert session.closed + assert all( + request[2]["Authorization"] == "Bearer right-key" + for request in state["requests"] + ) + assert json.loads(state["requests"][1][3]) == {"name": "pod"} + + +def test_sync_client_reuses_pool_and_borrows_sessions(http_server): + base, state = http_server + with requests.Session() as session: + session.headers["User-Agent"] = "caller-agent" + with SyncHTTPClient(base, session=session) as client: + for path in ("/first", "/second"): + with client.stream(Route("GET", path)) as response: + assert response.json() == {"ok": True} + assert session.get(f"{base}third").status_code == 200 + assert state["requests"][0][4] == state["requests"][1][4] + assert state["requests"][0][2]["User-Agent"] == "caller-agent" + + +def test_sync_rest_client_reuses_pool_and_closes_responses(http_server): + base, state = http_server + with RESTClient("key", base_url=base) as client: + session = client.session + assert client.request(Route("GET", "/v2/pods")) == {"ok": True} + assert client.request(Route("GET", "/v2/pods")) == {"ok": True} + assert client.session is session + assert client.session is None + assert state["requests"][0][4] == state["requests"][1][4] diff --git a/tests/test_api/test_rate_limit.py b/tests/test_api/test_rate_limit.py index 6104043ea..93ec4f16c 100644 --- a/tests/test_api/test_rate_limit.py +++ b/tests/test_api/test_rate_limit.py @@ -508,7 +508,7 @@ def test_sync_response_is_closed_before_sleep(monkeypatch, clock): second._content_consumed = True second.close = Mock() monkeypatch.setattr(rest, "rate_limits", _rate_limit._RateLimits()) - monkeypatch.setattr(rest.requests, "request", Mock(side_effect=[first, second])) + monkeypatch.setattr(requests.Session, "request", Mock(side_effect=[first, second])) def sleep(seconds): first.close.assert_called_once() diff --git a/tests/test_apps/test_api_client.py b/tests/test_apps/test_api_client.py index 3bbbfbce0..6637ee56d 100644 --- a/tests/test_apps/test_api_client.py +++ b/tests/test_apps/test_api_client.py @@ -6,7 +6,7 @@ import pytest from runpod.apps.api import AppsApiClient -from runpod.error import AuthenticationError, QueryError +from runpod.error import QueryError from runpod.user_agent import APPS_USER_AGENT @@ -730,61 +730,6 @@ async def test_secret_crud(self): assert await client.delete_secret("s1") is True -class TestAuthRequests: - async def test_create_auth_request_is_anonymous(self): - client = AppsApiClient(api_key="test-key") - transport = _respond( - {"createFlashAuthRequest": {"id": "req1", "status": "PENDING"}} - ) - with patch("runpod.apps.api.run_graphql_query_async", transport): - result = await client.create_auth_request() - assert result["id"] == "req1" - assert transport.call_args[1]["anonymous"] is True - - async def test_verify_api_key_sends_the_pasted_key(self): - client = AppsApiClient(api_key="stored-key") - transport = _respond({"myself": {"id": "user1"}}) - with patch("runpod.apps.api.run_graphql_query_async", transport): - assert await client.verify_api_key("rpa_new") is True - assert transport.call_args[1]["api_key"] == "rpa_new" - assert transport.call_args[1].get("anonymous", False) is False - - @pytest.mark.parametrize( - "outcome", - [ - AuthenticationError("Unauthorized request"), - QueryError("invalid api key", "query"), - {"data": {"myself": None}}, - {"data": None}, - ], - ) - async def test_verify_api_key_rejects(self, outcome): - transport = AsyncMock() - if isinstance(outcome, Exception): - transport.side_effect = outcome - else: - transport.return_value = outcome - with patch("runpod.apps.api.run_graphql_query_async", transport): - assert await AppsApiClient().verify_api_key("rpa_bad") is False - - async def test_verify_api_key_raises_on_transport_error(self): - transport = AsyncMock(side_effect=aiohttp.ClientConnectionError("down")) - with patch("runpod.apps.api.run_graphql_query_async", transport): - with pytest.raises(aiohttp.ClientConnectionError): - await AppsApiClient().verify_api_key("rpa_new") - - async def test_status_check_is_anonymous_and_never_asks_for_the_key(self): - client = AppsApiClient(api_key="test-key") - transport = _respond( - {"flashAuthRequestStatus": {"id": "req1", "status": "DENIED"}} - ) - with patch("runpod.apps.api.run_graphql_query_async", transport): - result = await client.get_auth_request_status("req1") - assert result["status"] == "DENIED" - assert transport.call_args[1]["anonymous"] is True - assert "apiKey" not in transport.call_args[0][0] - - class TestArtifacts: async def test_prepare_artifact_upload(self): client, patcher = _client_with( diff --git a/tests/test_apps/test_app.py b/tests/test_apps/test_app.py index 8ed986518..a45c42625 100644 --- a/tests/test_apps/test_app.py +++ b/tests/test_apps/test_app.py @@ -494,11 +494,11 @@ def test_live_pool_members_parses_catalog_and_fails_soft(self, monkeypatch): } fetch = _real_live_pool_members gpu_mod._clear_catalog_cache() - with patch("requests.request", return_value=resp) as get: + with patch("requests.Session.request", return_value=resp) as get: assert fetch() == {"AMPERE_24": {"NVIDIA L4"}} assert get.call_args.kwargs["headers"]["Authorization"] == "Bearer k" gpu_mod._clear_catalog_cache() - with patch("requests.request", side_effect=OSError("offline")) as get: + with patch("requests.Session.request", side_effect=OSError("offline")) as get: assert fetch() is None # a failure is not retried on every lookup assert fetch() is None @@ -506,7 +506,7 @@ def test_live_pool_members_parses_catalog_and_fails_soft(self, monkeypatch): # it is retried once the window passes cache = next(iter(gpu_mod._catalog_caches.values())) cache.failed_at -= gpu_mod.CATALOG_RETRY_SECONDS - with patch("requests.request", return_value=resp): + with patch("requests.Session.request", return_value=resp): assert fetch() == {"AMPERE_24": {"NVIDIA L4"}} gpu_mod._clear_catalog_cache() diff --git a/tests/test_apps/test_entrypoint_execution.py b/tests/test_apps/test_entrypoint_execution.py index 68d0c0b89..c14688c56 100644 --- a/tests/test_apps/test_entrypoint_execution.py +++ b/tests/test_apps/test_entrypoint_execution.py @@ -92,7 +92,7 @@ async def main(): from click.testing import CliRunner from runpod.apps.entrypoint import run_entrypoint from runpod.apps.targets import SentinelTarget -from runpod.rp_cli.main import cli +from runpod.cli.main import cli async def start(session): for app in session.apps: diff --git a/tests/test_apps/test_http_errors.py b/tests/test_apps/test_http_errors.py index 04a148f31..5a6560e94 100644 --- a/tests/test_apps/test_http_errors.py +++ b/tests/test_apps/test_http_errors.py @@ -79,7 +79,7 @@ async def test_transports_report_body_without_credentials( error_server, monkeypatch, tmp_path, operation, method, path, attempts ): monkeypatch.setattr("runpod.endpoint_url_base", "https://api.runpod.ai/v2") - monkeypatch.setattr("runpod.apps.logs.HAPI_BASE", "https://logs.example") + monkeypatch.setenv("RUNPOD_HAPI_URL", "https://logs.example") client = QueueClient( "ep", lambda: {"Authorization": "Bearer synthetic-account-key"} ) diff --git a/tests/test_apps/test_http_transport.py b/tests/test_apps/test_http_transport.py new file mode 100644 index 000000000..b1ecde81f --- /dev/null +++ b/tests/test_apps/test_http_transport.py @@ -0,0 +1,225 @@ +"""HTTP transport routing, ownership, and credentials for Apps operations.""" + +from contextlib import asynccontextmanager +from unittest.mock import AsyncMock, MagicMock, patch + +import pytest +from aiohttp import web + +import runpod +from runpod.api.http import HTTPClient +from runpod.apps.api import AppsApiClient +from runpod.apps.logs import pod_logs, stream_pod_logs +from runpod.apps.spec import ResourceKind, ResourceSpec +from runpod.apps.targets import QueueClient, _wait_terminal +from runpod.apps.tasks import TaskExecution +from runpod.apps.utils.network import get_json +from runpod.user_agent import APPS_USER_AGENT + + +@pytest.mark.parametrize("operation", ["status", "cancel", "retry", "stream"]) +async def test_queue_routes_escape_ids_and_preserve_base_path(monkeypatch, operation): + monkeypatch.setattr(runpod, "endpoint_url_base", "http://custom.test:8080/api/v2/") + client = QueueClient("endpoint/id ?#%", lambda: {"Authorization": "Bearer worker"}) + with patch( + "runpod.apps.targets._request_json", + AsyncMock(return_value={"status": "COMPLETED"}), + ) as request: + if operation == "stream": + assert [ + chunk async for chunk in client.stream("job/id ?#%", timeout=5) + ] == [] + else: + await getattr(client, operation)("job/id ?#%") + assert request.call_args.args[:3] == ( + "GET" if operation in {"status", "stream"} else "POST", + f"http://custom.test:8080/api/v2/endpoint%2Fid%20%3F%23%25/{operation}/job%2Fid%20%3F%23%25", + {"Authorization": "Bearer worker"}, + ) + assert request.call_args.kwargs["job_id"] == ( + "job/id ?#%" if operation == "status" else None + ) + + +async def test_poll_route_escapes_job_id(): + with ( + patch("runpod.apps.targets.asyncio.sleep", AsyncMock()), + patch( + "runpod.apps.targets._get_json", + AsyncMock(return_value={"status": "COMPLETED"}), + ) as request, + ): + await _wait_terminal( + "http://custom.test/prefix/endpoint", + {"id": "job/id?", "status": "IN_QUEUE"}, + {}, + 5, + ) + assert ( + request.call_args.args[0] + == "http://custom.test/prefix/endpoint/status/job%2Fid%3F" + ) + + +async def test_lb_transport_preserves_custom_scheme_and_port(monkeypatch): + monkeypatch.setattr(runpod, "endpoint_url_base", "http://custom.test:8080/api/v2") + response = MagicMock(status=200) + response.text = AsyncMock(return_value='{"ok": true}') + with patch("runpod.apps.targets.HTTPClient") as factory: + client = factory.return_value.__aenter__.return_value + client.stream = MagicMock() + client.stream.return_value.__aenter__.return_value = response + result = await QueueClient("endpoint", lambda: {}).http( + "POST", "/work", timeout=5 + ) + assert result == {"ok": True} + factory.assert_called_once_with(base_url="http://endpoint.custom.test:8080") + assert client.stream.call_args.args[0].resolved_path == "/work" + assert client.stream.call_args.args[0].method == "POST" + + +async def test_host_log_base_is_read_per_operation(monkeypatch): + monkeypatch.setenv("RUNPOD_API_KEY", "account-key") + with patch("runpod.apps.logs.HTTPClient") as factory: + response = MagicMock(status=200) + response.json = AsyncMock(return_value={"container": []}) + factory.return_value.stream.return_value.__aenter__.return_value = response + for base in ("http://one.test/prefix", "http://two.test/other"): + monkeypatch.setenv("RUNPOD_HAPI_URL", base) + await pod_logs("pod/id?#") + factory.assert_called_with(base_url=base) + route = factory.return_value.stream.call_args.args[0] + assert route.url(base) == f"{base}/v1/pod/pod%2Fid%3F%23/logs" + + +async def test_worker_log_route_escapes_both_ids(monkeypatch): + monkeypatch.setenv("RUNPOD_API_KEY", "account-key") + monkeypatch.setenv("RUNPOD_API_BASE_URL", "http://custom.test/prefix") + + async def content(): + yield b'data: {"line": "ready"}\n' + yield b"\n" + + response = MagicMock(status=200) + response.content = content() + with patch("runpod.apps.logs.HTTPClient") as factory: + client = factory.return_value.__aenter__.return_value + client.stream = MagicMock() + client.stream.return_value.__aenter__.return_value = response + assert [ + event + async for event in stream_pod_logs( + "pod/id", endpoint_id="endpoint?", log_type="system" + ) + ] == [{"line": "ready"}] + route = client.stream.call_args.args[0] + assert ( + route.url() + == "http://custom.test/prefix/v2/serverless/endpoint%3F/workers/pod%2Fid/logs" + ) + + +@pytest.mark.parametrize("operation", ["submit", "poll_result", "wait_ready"]) +async def test_task_retries_share_client_and_use_only_task_credentials( + monkeypatch, operation +): + monkeypatch.setenv("RUNPOD_API_KEY", "account-key") + execution = TaskExecution( + ResourceSpec(kind=ResourceKind.TASK, name="task"), api=MagicMock() + ) + execution.pod_id = "pod1" + responses = [MagicMock(status=404), MagicMock(status=200)] + responses[-1].json = AsyncMock( + return_value={"status": "DONE", "response": {"ok": True}} + ) + with ( + patch("runpod.apps.tasks.HTTPClient") as factory, + patch("runpod.apps.tasks.asyncio.sleep", AsyncMock()), + ): + client = factory.return_value.__aenter__.return_value + client.stream = MagicMock() + client.stream.return_value.__aenter__.side_effect = responses + if operation == "submit": + await execution.submit({"input": {}}) + elif operation == "poll_result": + assert await execution.poll_result() == {"ok": True} + else: + await execution.wait_ready(timeout=5) + factory.assert_called_once_with(base_url="https://pod1-8080.proxy.runpod.net") + assert client.stream.call_count == 2 + for call in client.stream.call_args_list: + assert call.kwargs.get("headers", {}) == ( + {"User-Agent": APPS_USER_AGENT} + if operation == "wait_ready" + else { + "Authorization": f"Bearer {execution.token}", + "User-Agent": APPS_USER_AGENT, + } + ) + factory.return_value.__aexit__.assert_awaited_once() + + +async def test_upload_reuses_session_and_preserves_presigned_query( + tmp_path, monkeypatch +): + monkeypatch.setenv("RUNPOD_API_KEY", "account-key") + tar = tmp_path / "app.tar.gz" + tar.write_bytes(b"payload") + requests = [] + sessions = [] + original_stream = HTTPClient.stream + + @asynccontextmanager + async def stream(client, *args, **kwargs): + sessions.append(client.session) + async with original_stream(client, *args, **kwargs) as response: + yield response + + async def upload(request): + requests.append((request.raw_path, dict(request.headers), await request.read())) + return web.Response(status=503 if len(requests) == 1 else 200) + + app = web.Application() + app.router.add_put("/upload", upload) + runner = web.AppRunner(app) + await runner.setup() + site = web.TCPSite(runner, "127.0.0.1", 0) + await site.start() + port = site._server.sockets[0].getsockname()[1] + try: + with ( + patch.object(HTTPClient, "stream", stream), + patch("asyncio.sleep", AsyncMock()), + ): + await AppsApiClient(api_key="explicit-account-key").upload_tarball( + f"http://127.0.0.1:{port}/upload?signature=a%2Fb%2Bz", str(tar) + ) + finally: + await runner.cleanup() + assert len(requests) == 2 + for path, headers, payload in requests: + assert path == "/upload?signature=a%2Fb%2Bz" + assert "Authorization" not in headers + assert payload == b"payload" + assert headers["Content-Type"] == "application/gzip" + assert len(sessions) == 2 + assert sessions[0] is sessions[1] + assert sessions[0].closed + + +async def test_network_get_uses_explicit_credentials(): + with patch("runpod.apps.utils.network.HTTPClient") as factory: + response = MagicMock(status=200) + response.json = AsyncMock(return_value={"ok": True}) + factory.return_value.stream.return_value.__aenter__.return_value = response + assert await get_json( + "http://custom.test/api?q=x", {"Authorization": "Bearer worker"}, 9 + ) == {"ok": True} + factory.assert_called_once_with(base_url="http://custom.test/api?q=x") + route = factory.return_value.stream.call_args.args[0] + assert route.method == "GET" + assert route.path == "" + assert factory.return_value.stream.call_args.kwargs == { + "headers": {"Authorization": "Bearer worker", "User-Agent": APPS_USER_AGENT}, + "timeout": 9, + } diff --git a/tests/test_apps/test_logs.py b/tests/test_apps/test_logs.py index f4f2fa167..4eeb6119c 100644 --- a/tests/test_apps/test_logs.py +++ b/tests/test_apps/test_logs.py @@ -37,17 +37,17 @@ def test_system_before_container(self): def _mock_session(response): - """a ClientSession whose get() context manager yields `response`.""" + """an HTTPClient whose stream yields the response.""" response.status = 200 get_cm = MagicMock() get_cm.__aenter__ = AsyncMock(return_value=response) get_cm.__aexit__ = AsyncMock(return_value=False) session = MagicMock() - session.get = MagicMock(return_value=get_cm) - session_cm = MagicMock() - session_cm.__aenter__ = AsyncMock(return_value=session) - session_cm.__aexit__ = AsyncMock(return_value=False) - return session_cm, session + session.stream = MagicMock(return_value=get_cm) + session.request = response.json + session.__aenter__ = AsyncMock(return_value=session) + session.__aexit__ = AsyncMock(return_value=False) + return session, session class TestPodLogs: @@ -58,13 +58,13 @@ async def test_snapshot_normalizes_nulls(self, monkeypatch): response.json = AsyncMock(return_value={"container": ["hello"], "system": None}) session_cm, session = _mock_session(response) - with patch("aiohttp.ClientSession", return_value=session_cm): + with patch("runpod.apps.logs.HTTPClient", return_value=session_cm): result = await pod_logs("pod123") assert result == {"container": ["hello"], "system": []} - url = session.get.call_args[0][0] - assert "pod123" in url - headers = session.get.call_args[1]["headers"] + route = session.stream.call_args[0][0] + assert "pod123" in route.resolved_path + headers = session.stream.call_args[1]["headers"] assert headers["Authorization"] == "Bearer test-key" @@ -97,7 +97,7 @@ async def test_combined_rest_stream_resumes_delivered_events( ) session_cm, session = _mock_session(response) cursors = [] - with patch("aiohttp.ClientSession", return_value=session_cm): + with patch("runpod.apps.logs.HTTPClient", return_value=session_cm): entries = [ entry async for entry in stream_pod_logs( @@ -108,15 +108,15 @@ async def test_combined_rest_stream_resumes_delivered_events( on_event_id=cursors.append, ) ] - url = session.get.call_args.args[0] + url = session.stream.call_args.args[0].resolved_path suffix = ( "/v2/serverless/ep1/workers/pod1/logs" if endpoint_id else "/v2/pods/pod1/logs" ) assert url.endswith(suffix) - assert session.get.call_args.kwargs["params"] == {"tail": "100"} - assert session.get.call_args.kwargs["headers"]["Last-Event-ID"] == "cursor1" + assert session.stream.call_args.kwargs["params"] == {"tail": "100"} + assert session.stream.call_args.kwargs["headers"]["Last-Event-ID"] == "cursor1" assert cursors == ["cursor2"] assert entries == [{"source": "system", "line": "ready", "ts": "t2"}] @@ -141,14 +141,14 @@ async def test_parses_sse_frames(self, monkeypatch): response.content = _FakeContent(frames) session_cm, session = _mock_session(response) - with patch("aiohttp.ClientSession", return_value=session_cm): + with patch("runpod.apps.logs.HTTPClient", return_value=session_cm): events = [e async for e in stream_pod_logs("pod123")] assert events == [ {"source": "container", "line": "hi", "ts": "t1"}, {"source": "system", "line": "boot", "ts": "t2"}, ] - params = session.get.call_args[1]["params"] + params = session.stream.call_args[1]["params"] assert params["stream"] == "true" assert params["tail"] == "100" @@ -167,7 +167,7 @@ async def test_cursor_matches_each_complete_frame(self, monkeypatch, id_first): response.content = _FakeContent(frames) session_cm, _ = _mock_session(response) cursors = [] - with patch("aiohttp.ClientSession", return_value=session_cm): + with patch("runpod.apps.logs.HTTPClient", return_value=session_cm): stream = stream_pod_logs("pod1", on_event_id=cursors.append) assert await anext(stream) == {"line": 0} assert cursors == ["cursor0"] @@ -190,7 +190,7 @@ async def test_multiline_data_and_incomplete_frames(self, monkeypatch): ) session_cm, _ = _mock_session(response) cursors = [] - with patch("aiohttp.ClientSession", return_value=session_cm): + with patch("runpod.apps.logs.HTTPClient", return_value=session_cm): events = [ e async for e in stream_pod_logs("pod1", on_event_id=cursors.append) ] @@ -220,8 +220,8 @@ async def connect(): await asyncio.sleep(0.03) return response - session.get.return_value.__aenter__.side_effect = connect - with patch("aiohttp.ClientSession", return_value=session_cm): + session.stream.return_value.__aenter__.side_effect = connect + with patch("runpod.apps.logs.HTTPClient", return_value=session_cm): stream = stream_pod_logs("pod1", idle_timeout=0.001) if status == 403: with pytest.raises(AppHTTPError) as raised: @@ -230,7 +230,7 @@ async def connect(): assert raised.value.body_excerpt == "forbidden" else: assert [e async for e in stream] == [{"line": "ready"}] - session.get.return_value.__aexit__.assert_awaited_once() + session.stream.return_value.__aexit__.assert_awaited_once() async def test_idle_timeout_closes_established_stream(self, monkeypatch): monkeypatch.setenv("RUNPOD_API_KEY", "test-key") @@ -247,19 +247,19 @@ async def content(): response = MagicMock() response.content = content() session_cm, session = _mock_session(response) - with patch("aiohttp.ClientSession", return_value=session_cm): + with patch("runpod.apps.logs.HTTPClient", return_value=session_cm): events = [e async for e in stream_pod_logs("pod1", idle_timeout=0.001)] assert events == [{"line": "ready"}] assert closed == [True] - session.get.return_value.__aexit__.assert_awaited_once() + session.stream.return_value.__aexit__.assert_awaited_once() async def test_connection_timeout_propagates(self, monkeypatch): monkeypatch.setenv("RUNPOD_API_KEY", "test-key") session_cm, session = _mock_session(MagicMock()) - session.get.return_value.__aenter__.side_effect = asyncio.TimeoutError( + session.stream.return_value.__aenter__.side_effect = asyncio.TimeoutError( "connection timed out" ) - with patch("aiohttp.ClientSession", return_value=session_cm): + with patch("runpod.apps.logs.HTTPClient", return_value=session_cm): with pytest.raises(asyncio.TimeoutError, match="connection timed out"): await anext(stream_pod_logs("pod1", idle_timeout=0.001)) diff --git a/tests/test_apps/test_retry.py b/tests/test_apps/test_retry.py index 09c608be3..1fe0b3a7a 100644 --- a/tests/test_apps/test_retry.py +++ b/tests/test_apps/test_retry.py @@ -4,12 +4,14 @@ import json import socket import threading +from contextlib import asynccontextmanager from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from unittest.mock import patch import aiohttp import pytest +from runpod.api.http import HTTPClient from runpod.apps.errors import AppHTTPError, EndpointNotFound from runpod.apps.targets import ( JOB_PROPAGATION_ATTEMPTS, @@ -74,6 +76,27 @@ async def test_retries_transient_5xx_then_succeeds(flaky_server): assert data["hits"] == 3 +async def test_read_retries_share_one_session_and_close_it(flaky_server): + flaky_server.state["script"] = [520, 502] + sessions = [] + original_stream = HTTPClient.stream + + @asynccontextmanager + async def stream(client, *args, **kwargs): + sessions.append(client.session) + async with original_stream(client, *args, **kwargs) as response: + yield response + + with ( + patch("runpod.apps.targets.RETRY_BASE_DELAY", 0.01), + patch.object(HTTPClient, "stream", stream), + ): + assert (await _request_json("GET", flaky_server.url, {}, timeout=10))["ok"] + assert len(sessions) == 3 + assert all(session is sessions[0] for session in sessions) + assert sessions[0].closed + + async def test_exhausted_retries_raise_last_error(flaky_server): flaky_server.state["script"] = [503] * (RETRY_ATTEMPTS + 2) with patch("runpod.apps.targets.RETRY_BASE_DELAY", 0.01): diff --git a/tests/test_apps/test_targets.py b/tests/test_apps/test_targets.py index 84e46c461..803ca632b 100644 --- a/tests/test_apps/test_targets.py +++ b/tests/test_apps/test_targets.py @@ -8,6 +8,7 @@ import pytest +from runpod.api.routes import load_balancer_base_url from runpod.apps.errors import RemoteExecutionError from runpod.apps.spec import ResourceKind, ResourceSpec from runpod.apps.targets import ( @@ -16,7 +17,6 @@ SentinelTarget, _api_key, _headers, - _lb_domain, _wait_terminal, args_to_input, unwrap_job_output, @@ -49,7 +49,7 @@ def test_lb_domain(self, monkeypatch): import runpod monkeypatch.setattr(runpod, "endpoint_url_base", "https://api.runpod.ai/v2") - assert _lb_domain() == "api.runpod.ai" + assert load_balancer_base_url("endpoint") == "https://endpoint.api.runpod.ai" def test_headers(self, monkeypatch): monkeypatch.setenv("RUNPOD_API_KEY", "sk-test") diff --git a/tests/test_apps/test_tasks.py b/tests/test_apps/test_tasks.py index ab2c4d88d..00e61df82 100644 --- a/tests/test_apps/test_tasks.py +++ b/tests/test_apps/test_tasks.py @@ -510,16 +510,16 @@ async def test_runtime_must_acknowledge_timeout(self, method, acknowledged): ) session = MagicMock() session.__aenter__.return_value = session - session.post.return_value.__aenter__.return_value = response - with patch("runpod.apps.tasks.aiohttp.ClientSession", return_value=session): + session.stream.return_value.__aenter__.return_value = response + with patch("runpod.apps.tasks.HTTPClient", return_value=session): argument = {"timeout": 60} if method == "submit" else 60 if acknowledged: await getattr(execution, method)(argument) else: with pytest.raises(RuntimeError, match="did not acknowledge"): await getattr(execution, method)(argument) - assert session.post.call_args.kwargs["json"] == {"timeout": 60} - assert session.post.call_args.kwargs["headers"] == execution._headers + assert session.stream.call_args.kwargs["json"] == {"timeout": 60} + assert session.stream.call_args.kwargs["headers"] == execution._headers @pytest.mark.parametrize("timeout", [-1, True, "60", float("nan"), float("inf")]) async def test_invalid_timeouts_fail_before_http(self, timeout): @@ -528,7 +528,7 @@ async def test_invalid_timeouts_fail_before_http(self, timeout): execution = TaskExecution( ResourceSpec(kind=ResourceKind.TASK, name="t"), api=MagicMock() ) - with patch("runpod.apps.tasks.aiohttp.ClientSession") as session: + with patch("runpod.apps.tasks.HTTPClient") as session: with pytest.raises(ValueError, match="finite non-negative"): await execution.set_timeout(timeout) session.assert_not_called() diff --git a/tests/test_apps/test_transport_parity.py b/tests/test_apps/test_transport_parity.py index 55fb99b24..787d3d2b4 100644 --- a/tests/test_apps/test_transport_parity.py +++ b/tests/test_apps/test_transport_parity.py @@ -76,7 +76,7 @@ def work(value, flag): @pytest.mark.parametrize("value", [b"bytes", float("nan"), float("inf")]) async def test_api_body_validation_precedes_requests_and_source_sync(target, value): with ( - patch("runpod.apps.targets.aiohttp.ClientSession") as session, + patch("runpod.apps.targets.HTTPClient") as session, patch.object(LiveTarget, "_sync_source", AsyncMock()) as sync, ): with pytest.raises( @@ -88,7 +88,7 @@ async def test_api_body_validation_precedes_requests_and_source_sync(target, val async def test_raw_queue_requests_reject_non_json_options_before_network(): - with patch("runpod.apps.targets.aiohttp.ClientSession") as session: + with patch("runpod.apps.targets.HTTPClient") as session: with pytest.raises(ValueError, match="remote request body"): await _request_json( "POST", @@ -120,16 +120,16 @@ def test_queue_and_task_results_reject_non_finite_json(value): async def test_api_json_and_text_responses_share_transport(target, text, expected): with ( patch.object(target._client, "_headers", return_value={}), - patch("runpod.apps.targets.aiohttp.ClientSession") as factory, + patch("runpod.apps.targets.HTTPClient") as factory, ): session = factory.return_value.__aenter__.return_value - session.request = MagicMock() - response = session.request.return_value.__aenter__.return_value + session.stream = MagicMock() + response = session.stream.return_value.__aenter__.return_value response.status = 200 response.text = AsyncMock(return_value=text) response.raise_for_status = lambda: None assert await target.request("POST", "/work", {"value": 1}) == expected - assert session.request.call_args.kwargs["json"] == {"value": 1} + assert session.stream.call_args.kwargs["json"] == {"value": 1} @pytest.mark.parametrize("async_call", [False, True]) diff --git a/tests/test_apps/test_user_agent.py b/tests/test_apps/test_user_agent.py index 4b1103c04..f3cfbd8b0 100644 --- a/tests/test_apps/test_user_agent.py +++ b/tests/test_apps/test_user_agent.py @@ -15,7 +15,8 @@ from runpod.api.rest import run_rest_request, run_rest_request_async from runpod.apps import gpu, logs, tasks from runpod.apps.api import AppsApiClient, FlashTaskApiClient -from runpod.apps.auth import agent_login +from runpod.auth.api import AuthApiClient +from runpod.auth.login import agent_login from runpod.apps.gpu import live_pool_members, live_pool_members_async from runpod.apps.targets import LiveTarget, SentinelTarget from runpod.apps.utils.network import get_json @@ -55,7 +56,7 @@ def log_message(self, *args): monkeypatch.setenv("RUNPOD_API_KEY", "test-key") monkeypatch.setattr(runpod, "api_key", "test-key") monkeypatch.setattr(runpod, "endpoint_url_base", state.url) - monkeypatch.setattr(logs, "HAPI_BASE", state.url) + monkeypatch.setenv("RUNPOD_HAPI_URL", state.url) monkeypatch.setattr(tasks, "_proxy_url", lambda pod_id: state.url) monkeypatch.setattr("runpod.apps.context.deployed_identity", lambda: None) gpu._clear_catalog_cache() @@ -104,7 +105,7 @@ async def query(*args, **kwargs): async def test_verify_api_key(server): server.responses = [{"data": {"myself": {"id": "user"}}}] - assert await AppsApiClient().verify_api_key("test-key") + assert await AuthApiClient().verify_api_key("test-key") @pytest.mark.parametrize("runtime", [None, "endpoint", "pod"]) @@ -219,7 +220,7 @@ async def test_queue_and_load_balancer(server, target, operation, monkeypatch): original = aiohttp.ClientSession._request async def request(session, method, url, **kwargs): - assert url.startswith("https://") + assert str(url).startswith(f"http://{client.endpoint_id}.127.0.0.1:") return await original(session, method, server.url + "/route", **kwargs) monkeypatch.setattr(aiohttp.ClientSession, "_request", request) @@ -333,7 +334,7 @@ def test_volume_transfer_caller_attribution( from click.testing import CliRunner from runpod.apps import NetworkVolume - from runpod.rp_cli.main import cli + from runpod.cli.main import cli server.user_agent = APPS_USER_AGENT if caller == "apps" else USER_AGENT server.responses = [ @@ -342,7 +343,7 @@ def test_volume_transfer_caller_attribution( "pagination": {"hasNextPage": False}, } ] - monkeypatch.setattr("runpod.rp_cli.update.start_background_check", lambda: None) + monkeypatch.setattr("runpod.cli.update.start_background_check", lambda: None) local = tmp_path / "model.bin" local.write_bytes(b"model") source, target = ( diff --git a/tests/test_auth/__init__.py b/tests/test_auth/__init__.py new file mode 100644 index 000000000..87798a67b --- /dev/null +++ b/tests/test_auth/__init__.py @@ -0,0 +1 @@ +"""account authentication tests.""" diff --git a/tests/test_apps/test_agent_auth.py b/tests/test_auth/test_agent_login.py similarity index 94% rename from tests/test_apps/test_agent_auth.py rename to tests/test_auth/test_agent_login.py index 69c2230da..680a6b7ed 100644 --- a/tests/test_apps/test_agent_auth.py +++ b/tests/test_auth/test_agent_login.py @@ -14,7 +14,8 @@ import pytest import runpod -from runpod.apps.auth import LoginError, _post_authentication_attempt, agent_login +from runpod.auth.login import LoginError, _post_authentication_attempt, agent_login +from runpod.api.routes import Route from runpod.user_agent import APPS_USER_AGENT @@ -235,11 +236,11 @@ def test_aborted_code_prompt_does_not_verify(signup_server): @pytest.mark.parametrize("error", [asyncio.TimeoutError, aiohttp.ClientConnectionError]) def test_transport_failures_are_sanitized(error): session = MagicMock() - session.post.return_value.__aenter__ = AsyncMock(side_effect=error("secret")) + session.stream.return_value.__aenter__ = AsyncMock(side_effect=error("secret")) with pytest.raises(LoginError, match="check your connection") as exc: - asyncio.run(_post_authentication_attempt(session, "/path", {})) + asyncio.run(_post_authentication_attempt(session, Route("POST", "/path"), {})) assert "secret" not in str(exc.value) - session.post.assert_called_once() + session.stream.assert_called_once() def test_two_step_login_across_processes(signup_server, tmp_path): @@ -257,9 +258,9 @@ def test_two_step_login_across_processes(signup_server, tmp_path): command = [ sys.executable, "-c", - "from runpod.rp_cli import update; " + "from runpod.cli import update; " "update.start_background_check = lambda: None; " - "from runpod.rp_cli.main import run; run()", + "from runpod.cli.main import run; run()", "login", "--agent", "--profile", @@ -313,12 +314,12 @@ def test_two_step_login_across_processes(signup_server, tmp_path): def test_two_step_rejected_code_can_be_retried(signup_server, monkeypatch, tmp_path): from click.testing import CliRunner - from runpod.apps.auth import load_agent_login, pending_agent_login_path - from runpod.cli.groups.config import functions - from runpod.rp_cli.main import cli + from runpod.auth.login import load_agent_login, pending_agent_login_path + from runpod.auth import credentials as functions + from runpod.cli.main import cli monkeypatch.setattr(functions, "CREDENTIAL_FILE", str(tmp_path / "config.toml")) - monkeypatch.setattr("runpod.rp_cli.update.start_background_check", lambda: None) + monkeypatch.setattr("runpod.cli.update.start_background_check", lambda: None) monkeypatch.setattr( "click.prompt", MagicMock(side_effect=AssertionError("unexpected prompt")) ) diff --git a/tests/test_auth/test_api.py b/tests/test_auth/test_api.py new file mode 100644 index 000000000..4ebea7455 --- /dev/null +++ b/tests/test_auth/test_api.py @@ -0,0 +1,74 @@ +"""account authentication transport.""" + +from unittest.mock import AsyncMock, patch + +import aiohttp +import pytest + +import runpod +from runpod.auth.api import AuthApiClient +from runpod.error import AuthenticationError, QueryError + + +@pytest.fixture(autouse=True) +def stored_key(monkeypatch): + monkeypatch.setattr(runpod, "api_key", "stored-key") + + +def _respond(data): + return AsyncMock(return_value={"data": data}) + + +class TestAuthRequests: + async def test_create_auth_request_is_anonymous(self): + client = AuthApiClient() + transport = _respond( + {"createFlashAuthRequest": {"id": "req1", "status": "PENDING"}} + ) + with patch("runpod.auth.api.run_graphql_query_async", transport): + result = await client.create_auth_request() + assert result["id"] == "req1" + assert transport.call_args[1]["anonymous"] is True + + async def test_verify_api_key_sends_the_pasted_key(self): + client = AuthApiClient() + transport = _respond({"myself": {"id": "user1"}}) + with patch("runpod.auth.api.run_graphql_query_async", transport): + assert await client.verify_api_key("rpa_new") is True + assert transport.call_args[1]["api_key"] == "rpa_new" + assert transport.call_args[1].get("anonymous", False) is False + + @pytest.mark.parametrize( + "outcome", + [ + AuthenticationError("Unauthorized request"), + QueryError("invalid api key", "query"), + {"data": {"myself": None}}, + {"data": None}, + ], + ) + async def test_verify_api_key_rejects(self, outcome): + transport = AsyncMock() + if isinstance(outcome, Exception): + transport.side_effect = outcome + else: + transport.return_value = outcome + with patch("runpod.auth.api.run_graphql_query_async", transport): + assert await AuthApiClient().verify_api_key("rpa_bad") is False + + async def test_verify_api_key_raises_on_transport_error(self): + transport = AsyncMock(side_effect=aiohttp.ClientConnectionError("down")) + with patch("runpod.auth.api.run_graphql_query_async", transport): + with pytest.raises(aiohttp.ClientConnectionError): + await AuthApiClient().verify_api_key("rpa_new") + + async def test_status_check_is_anonymous_and_never_asks_for_the_key(self): + client = AuthApiClient() + transport = _respond( + {"flashAuthRequestStatus": {"id": "req1", "status": "DENIED"}} + ) + with patch("runpod.auth.api.run_graphql_query_async", transport): + result = await client.get_auth_request_status("req1") + assert result["status"] == "DENIED" + assert transport.call_args[1]["anonymous"] is True + assert "apiKey" not in transport.call_args[0][0] diff --git a/tests/test_cli/test_cli_groups/test_config_functions.py b/tests/test_auth/test_credentials.py similarity index 71% rename from tests/test_cli/test_cli_groups/test_config_functions.py rename to tests/test_auth/test_credentials.py index abb5b1187..ec96d8c19 100644 --- a/tests/test_cli/test_cli_groups/test_config_functions.py +++ b/tests/test_auth/test_credentials.py @@ -5,7 +5,7 @@ import unittest from unittest.mock import mock_open, patch -from runpod.cli.groups.config import functions +from runpod.auth import credentials as functions class TestConfig(unittest.TestCase): @@ -14,14 +14,14 @@ class TestConfig(unittest.TestCase): def setUp(self) -> None: self.sample_credentials = "[default]\n" 'api_key = "RUNPOD_API_KEY"\n' - @patch("runpod.cli.groups.config.functions.os.replace") - @patch("runpod.cli.groups.config.functions.os.unlink") - @patch("runpod.cli.groups.config.functions.os.fdopen", new_callable=mock_open) - @patch("runpod.cli.groups.config.functions.tempfile.mkstemp") - @patch("runpod.cli.groups.config.functions.tomlkit.dump") - @patch("runpod.cli.groups.config.functions.tomlkit.document") - @patch("runpod.cli.groups.config.functions.Path.touch") - @patch("runpod.cli.groups.config.functions.os.makedirs") + @patch("runpod.auth.credentials.os.replace") + @patch("runpod.auth.credentials.os.unlink") + @patch("runpod.auth.credentials.os.fdopen", new_callable=mock_open) + @patch("runpod.auth.credentials.tempfile.mkstemp") + @patch("runpod.auth.credentials.tomlkit.dump") + @patch("runpod.auth.credentials.tomlkit.document") + @patch("runpod.auth.credentials.Path.touch") + @patch("runpod.auth.credentials.os.makedirs") @patch("builtins.open", new_callable=mock_open, read_data="") def test_set_credentials( self, mock_file, _mock_makedirs, _mock_touch, mock_document, @@ -50,13 +50,13 @@ def test_set_credentials( "Profile already exists. Use set_credentials(overwrite=True) to update.", ) - @patch("runpod.cli.groups.config.functions.os.replace") - @patch("runpod.cli.groups.config.functions.os.unlink") - @patch("runpod.cli.groups.config.functions.os.fdopen", new_callable=mock_open) - @patch("runpod.cli.groups.config.functions.tempfile.mkstemp") - @patch("runpod.cli.groups.config.functions.tomlkit.dump") - @patch("runpod.cli.groups.config.functions.Path.touch") - @patch("runpod.cli.groups.config.functions.os.makedirs") + @patch("runpod.auth.credentials.os.replace") + @patch("runpod.auth.credentials.os.unlink") + @patch("runpod.auth.credentials.os.fdopen", new_callable=mock_open) + @patch("runpod.auth.credentials.tempfile.mkstemp") + @patch("runpod.auth.credentials.tomlkit.dump") + @patch("runpod.auth.credentials.Path.touch") + @patch("runpod.auth.credentials.os.makedirs") @patch( "builtins.open", new_callable=mock_open, @@ -79,8 +79,8 @@ def test_set_credentials_preserves_existing_profiles( assert dumped_config["profile2"]["api_key"] == "NEW_KEY" @patch("builtins.open", new_callable=mock_open()) - @patch("runpod.cli.groups.config.functions.toml.load") - @patch("runpod.cli.groups.config.functions.os.path.exists") + @patch("runpod.auth.credentials.toml.load") + @patch("runpod.auth.credentials.os.path.exists") def test_check_credentials(self, mock_exists, mock_toml_load, mock_file): """mock_open_call Tests the check_credentials function. @@ -109,7 +109,7 @@ def test_check_credentials(self, mock_exists, mock_toml_load, mock_file): assert passed is True @patch("os.path.exists", return_value=True) - @patch("runpod.cli.groups.config.functions.toml.load") + @patch("runpod.auth.credentials.toml.load") @patch( "builtins.open", new_callable=mock_open, read_data='[default]\nkey = "value"' ) @@ -126,7 +126,7 @@ def test_get_credentials_existing_profile( assert mock_exists.called @patch("os.path.exists", return_value=True) - @patch("runpod.cli.groups.config.functions.toml.load") + @patch("runpod.auth.credentials.toml.load") @patch( "builtins.open", new_callable=mock_open, read_data='[default]\nkey = "value"' ) @@ -142,9 +142,9 @@ def test_get_credentials_non_existent_profile( assert mock_open_call.called assert mock_exists.called - @patch("runpod.cli.groups.config.functions.os.path.exists", return_value=True) + @patch("runpod.auth.credentials.os.path.exists", return_value=True) @patch( - "runpod.cli.groups.config.functions.toml.load", + "runpod.auth.credentials.toml.load", side_effect=ValueError("Invalid value"), ) @patch("builtins.open", new_callable=mock_open) @@ -155,9 +155,9 @@ def test_get_credentials_corrupted_toml( result = functions.get_credentials("default") assert result is None - @patch("runpod.cli.groups.config.functions.os.path.exists", return_value=True) + @patch("runpod.auth.credentials.os.path.exists", return_value=True) @patch( - "runpod.cli.groups.config.functions.toml.load", + "runpod.auth.credentials.toml.load", side_effect=TypeError("bad type"), ) @patch("builtins.open", new_callable=mock_open) @@ -168,13 +168,13 @@ def test_get_credentials_type_error( result = functions.get_credentials("default") assert result is None - @patch("runpod.cli.groups.config.functions.os.replace") - @patch("runpod.cli.groups.config.functions.os.unlink") - @patch("runpod.cli.groups.config.functions.os.fdopen", new_callable=mock_open) - @patch("runpod.cli.groups.config.functions.tempfile.mkstemp") - @patch("runpod.cli.groups.config.functions.tomlkit.dump") - @patch("runpod.cli.groups.config.functions.Path.touch") - @patch("runpod.cli.groups.config.functions.os.makedirs") + @patch("runpod.auth.credentials.os.replace") + @patch("runpod.auth.credentials.os.unlink") + @patch("runpod.auth.credentials.os.fdopen", new_callable=mock_open) + @patch("runpod.auth.credentials.tempfile.mkstemp") + @patch("runpod.auth.credentials.tomlkit.dump") + @patch("runpod.auth.credentials.Path.touch") + @patch("runpod.auth.credentials.os.makedirs") @patch( "builtins.open", new_callable=mock_open, @@ -191,13 +191,13 @@ def test_set_credentials_overwrite_replaces_existing_profile( dumped_config = mock_dump.call_args[0][0] assert dumped_config["default"]["api_key"] == "NEW_KEY" - @patch("runpod.cli.groups.config.functions.os.replace") - @patch("runpod.cli.groups.config.functions.os.unlink") - @patch("runpod.cli.groups.config.functions.os.fdopen", new_callable=mock_open) - @patch("runpod.cli.groups.config.functions.tempfile.mkstemp") - @patch("runpod.cli.groups.config.functions.tomlkit.dump", side_effect=OSError("disk full")) - @patch("runpod.cli.groups.config.functions.Path.touch") - @patch("runpod.cli.groups.config.functions.os.makedirs") + @patch("runpod.auth.credentials.os.replace") + @patch("runpod.auth.credentials.os.unlink") + @patch("runpod.auth.credentials.os.fdopen", new_callable=mock_open) + @patch("runpod.auth.credentials.tempfile.mkstemp") + @patch("runpod.auth.credentials.tomlkit.dump", side_effect=OSError("disk full")) + @patch("runpod.auth.credentials.Path.touch") + @patch("runpod.auth.credentials.os.makedirs") @patch("builtins.open", new_callable=mock_open, read_data="") def test_set_credentials_cleans_up_temp_on_dump_failure( self, _mock_file, _mock_makedirs, _mock_touch, _mock_dump, @@ -211,12 +211,12 @@ def test_set_credentials_cleans_up_temp_on_dump_failure( mock_unlink.assert_called_once_with("/tmp/cred.toml") mock_replace.assert_not_called() - @patch("runpod.cli.groups.config.functions.os.replace") - @patch("runpod.cli.groups.config.functions.os.unlink") - @patch("runpod.cli.groups.config.functions.tempfile.mkstemp") - @patch("runpod.cli.groups.config.functions.tomlkit.dump") - @patch("runpod.cli.groups.config.functions.Path.touch") - @patch("runpod.cli.groups.config.functions.os.makedirs") + @patch("runpod.auth.credentials.os.replace") + @patch("runpod.auth.credentials.os.unlink") + @patch("runpod.auth.credentials.tempfile.mkstemp") + @patch("runpod.auth.credentials.tomlkit.dump") + @patch("runpod.auth.credentials.Path.touch") + @patch("runpod.auth.credentials.os.makedirs") @patch("builtins.open", new_callable=mock_open, read_data="not valid toml {{{") def test_set_credentials_corrupted_toml_raises( self, _mock_file, _mock_makedirs, _mock_touch, _mock_dump, diff --git a/tests/test_apps/test_auth.py b/tests/test_auth/test_login.py similarity index 98% rename from tests/test_apps/test_auth.py rename to tests/test_auth/test_login.py index 14ca01349..39bfa0aea 100644 --- a/tests/test_apps/test_auth.py +++ b/tests/test_auth/test_login.py @@ -6,7 +6,7 @@ import aiohttp import pytest -from runpod.apps.auth import LoginError, auth_url, browser_login +from runpod.auth.login import LoginError, auth_url, browser_login def _api(valid_keys=("rpa_new",), status="PENDING"): diff --git a/tests/test_auth/test_package.py b/tests/test_auth/test_package.py new file mode 100644 index 000000000..4d2c317e2 --- /dev/null +++ b/tests/test_auth/test_package.py @@ -0,0 +1,113 @@ +"""shared authentication and package boundaries.""" + +import os +import importlib +import subprocess +import sys + +import pytest + +import runpod +from runpod.auth import credentials, load_api_key, resolve_api_key +from runpod.error import AuthenticationError + + +def test_environment_key_precedes_stored_profile(monkeypatch): + monkeypatch.setenv("RUNPOD_API_KEY", "environment-key") + + def unexpected_read(*args): + raise AssertionError("credentials should not be read") + + monkeypatch.setattr(credentials, "get_credentials", unexpected_read) + assert load_api_key("agent") == "environment-key" + + +def test_load_selected_profile(monkeypatch, tmp_path): + monkeypatch.delenv("RUNPOD_API_KEY", raising=False) + monkeypatch.setattr(credentials, "CREDENTIAL_FILE", str(tmp_path / "config.toml")) + credentials.set_credentials("default-key") + credentials.set_credentials("agent-key", profile="agent") + assert load_api_key() == "default-key" + assert load_api_key("agent") == "agent-key" + assert load_api_key("missing") is None + + +def test_missing_credentials_are_optional(monkeypatch, tmp_path): + monkeypatch.delenv("RUNPOD_API_KEY", raising=False) + monkeypatch.setattr(credentials, "CREDENTIAL_FILE", str(tmp_path / "missing.toml")) + assert load_api_key() is None + + +def test_resolve_explicit_and_configured_keys(monkeypatch): + monkeypatch.setattr(runpod, "api_key", "configured-key") + assert resolve_api_key("explicit-key") == "explicit-key" + assert resolve_api_key() == "configured-key" + monkeypatch.setattr(runpod, "api_key", None) + with pytest.raises(AuthenticationError, match="No API key provided"): + resolve_api_key() + + +def test_transports_share_key_resolution(): + from runpod.api import graphql, rest + + assert graphql._resolve_api_key is resolve_api_key + assert rest._resolve_api_key is resolve_api_key + + +def test_public_credential_functions_use_auth_package(): + assert runpod.get_credentials is credentials.get_credentials + assert runpod.set_credentials is credentials.set_credentials + assert runpod.check_credentials is credentials.check_credentials + + +def test_flash_credential_import_uses_shared_module(monkeypatch, tmp_path): + import runpod.cli.groups.config.functions as flash_credentials + + assert flash_credentials is credentials + assert importlib.import_module("runpod.cli.groups.config.functions") is credentials + monkeypatch.setattr( + flash_credentials, "CREDENTIAL_FILE", str(tmp_path / "config.toml") + ) + flash_credentials.set_credentials("profile-key") + assert credentials.get_credentials() == {"api_key": "profile-key"} + + +def test_login_import_does_not_load_apps_or_cli(): + result = subprocess.run( + [ + sys.executable, + "-c", + "import sys, runpod.auth.login; " + "assert 'runpod.apps' not in sys.modules; " + "assert 'runpod.cli' not in sys.modules", + ], + capture_output=True, + text=True, + check=False, + ) + assert result.returncode == 0, result.stderr + + +@pytest.mark.parametrize("environment_key", [None, "environment-key"]) +def test_sdk_import_does_not_load_cli_or_login(monkeypatch, tmp_path, environment_key): + monkeypatch.setenv("HOME", str(tmp_path)) + monkeypatch.delenv("RUNPOD_API_KEY", raising=False) + if environment_key is not None: + monkeypatch.setenv("RUNPOD_API_KEY", environment_key) + result = subprocess.run( + [ + sys.executable, + "-c", + "import sys, runpod; " + "assert 'runpod.cli' not in sys.modules; " + "assert 'runpod.auth.login' not in sys.modules; " + "assert 'runpod.apps' not in sys.modules; " + "assert 'click' not in sys.modules; " + "assert 'paramiko' not in sys.modules", + ], + env=os.environ.copy(), + capture_output=True, + text=True, + check=False, + ) + assert result.returncode == 0, result.stderr diff --git a/tests/test_cli/test_agent_login.py b/tests/test_cli/test_agent_login.py index 7473f7113..7291ed3d6 100644 --- a/tests/test_cli/test_agent_login.py +++ b/tests/test_cli/test_agent_login.py @@ -7,9 +7,9 @@ import pytest from click.testing import CliRunner -from runpod.apps.auth import LoginError -from runpod.cli.groups.config import functions -from runpod.rp_cli.main import cli +from runpod.auth.login import LoginError +from runpod.auth import credentials as functions +from runpod.cli.main import cli @pytest.fixture @@ -19,16 +19,16 @@ def login_env(monkeypatch, tmp_path): '[default]\napi_key = "keep-default"\n' '[agent]\napi_key = "old-agent"\n' ) monkeypatch.setattr(functions, "CREDENTIAL_FILE", str(credentials)) - monkeypatch.setattr("runpod.rp_cli.update.start_background_check", lambda: None) + monkeypatch.setattr("runpod.cli.update.start_background_check", lambda: None) browser = AsyncMock(side_effect=AssertionError("unexpected browser login")) launch = MagicMock(side_effect=AssertionError("unexpected browser launch")) - monkeypatch.setattr("runpod.apps.auth.browser_login", browser) + monkeypatch.setattr("runpod.auth.login.browser_login", browser) monkeypatch.setattr("click.launch", launch) monkeypatch.setattr( "click.prompt", MagicMock(side_effect=AssertionError("unexpected prompt")) ) monkeypatch.setattr( - "runpod.apps.auth.start_agent_login", + "runpod.auth.login.start_agent_login", AsyncMock( return_value={ "attempt_id": "att_test", @@ -41,7 +41,7 @@ def login_env(monkeypatch, tmp_path): def test_agent_saves_named_profile_and_hides_code_and_key(login_env, monkeypatch): - from runpod.apps.auth import load_agent_login + from runpod.auth.login import load_agent_login async def authenticate(email): assert email == "owner@example.com" @@ -51,9 +51,9 @@ async def authenticate(email): "api_url": "https://api.runpod.io/v2/signup/authentication-attempts", } - monkeypatch.setattr("runpod.apps.auth.start_agent_login", authenticate) + monkeypatch.setattr("runpod.auth.login.start_agent_login", authenticate) verify = AsyncMock(return_value="rpa_new-agent-key") - monkeypatch.setattr("runpod.apps.auth.verify_agent_login", verify) + monkeypatch.setattr("runpod.auth.login.verify_agent_login", verify) result = CliRunner().invoke( cli, ["login", "--agent", "--email", " owner@example.com ", "--profile", "agent"], @@ -96,7 +96,7 @@ def test_invalid_options_have_no_auth_or_storage_side_effects( ): before = login_env.read_bytes() authenticate = AsyncMock() - monkeypatch.setattr("runpod.apps.auth.start_agent_login", authenticate) + monkeypatch.setattr("runpod.auth.login.start_agent_login", authenticate) result = CliRunner().invoke(cli, ["login", *args]) assert result.exit_code == 2 assert message in result.output @@ -107,7 +107,7 @@ def test_invalid_options_have_no_auth_or_storage_side_effects( def test_code_format_is_validated_without_echoing_input(login_env, monkeypatch): verify = AsyncMock(return_value="rpa_test") - monkeypatch.setattr("runpod.apps.auth.verify_agent_login", verify) + monkeypatch.setattr("runpod.auth.login.verify_agent_login", verify) runner = CliRunner() sent = runner.invoke( cli, ["login", "--agent", "--email", "owner@example.com", "--no-open"] @@ -139,7 +139,7 @@ def test_email_request_exits_without_stdin_and_preserves_credentials(login_env): def test_auth_error_preserves_credentials(login_env, monkeypatch): before = login_env.read_bytes() monkeypatch.setattr( - "runpod.apps.auth.start_agent_login", + "runpod.auth.login.start_agent_login", AsyncMock(side_effect=LoginError("code rejected")), ) result = CliRunner().invoke( @@ -155,7 +155,7 @@ def test_credential_write_failure_is_reported(login_env, monkeypatch): sent = CliRunner().invoke(cli, ["login", "--agent", "--email", "owner@example.com"]) assert sent.exit_code == 0, sent.output monkeypatch.setattr( - "runpod.apps.auth.verify_agent_login", AsyncMock(return_value="rpa_test") + "runpod.auth.login.verify_agent_login", AsyncMock(return_value="rpa_test") ) monkeypatch.setattr( functions, "set_credentials", MagicMock(side_effect=OSError("disk full")) @@ -169,7 +169,7 @@ def test_credential_write_failure_is_reported(login_env, monkeypatch): def test_direct_key_login_does_not_start_email_flow(login_env, monkeypatch): authenticate = AsyncMock() - monkeypatch.setattr("runpod.apps.auth.start_agent_login", authenticate) + monkeypatch.setattr("runpod.auth.login.start_agent_login", authenticate) result = CliRunner().invoke(cli, ["login", "--api-key", "rpa_direct"]) assert result.exit_code == 0 authenticate.assert_not_called() @@ -183,7 +183,7 @@ def test_agent_retry_explains_rejection_without_resending_notice( verify = AsyncMock( side_effect=[LoginError("verification code rejected"), "rpa_test"] ) - monkeypatch.setattr("runpod.apps.auth.verify_agent_login", verify) + monkeypatch.setattr("runpod.auth.login.verify_agent_login", verify) runner = CliRunner() sent = runner.invoke(cli, ["login", "--agent", "--email", "owner@example.com"]) assert sent.exit_code == 0, sent.output @@ -237,8 +237,8 @@ def test_two_step_invalid_options_do_not_authenticate( ): start = AsyncMock() verify = AsyncMock() - monkeypatch.setattr("runpod.apps.auth.start_agent_login", start) - monkeypatch.setattr("runpod.apps.auth.verify_agent_login", verify) + monkeypatch.setattr("runpod.auth.login.start_agent_login", start) + monkeypatch.setattr("runpod.auth.login.verify_agent_login", verify) before = login_env.read_bytes() result = CliRunner().invoke(cli, ["login", *args]) assert result.exit_code == 2 @@ -251,7 +251,7 @@ def test_two_step_invalid_options_do_not_authenticate( def test_two_step_missing_state_does_not_authenticate(login_env, monkeypatch): verify = AsyncMock() - monkeypatch.setattr("runpod.apps.auth.verify_agent_login", verify) + monkeypatch.setattr("runpod.auth.login.verify_agent_login", verify) result = CliRunner().invoke(cli, ["login", "--agent", "--code", "012345"]) assert result.exit_code == 1 assert "no pending login" in result.output @@ -262,11 +262,11 @@ def test_two_step_missing_state_does_not_authenticate(login_env, monkeypatch): "content", ["not json", "[]", "{}", '{"verifier": "sensitive"}'] ) def test_two_step_invalid_state_is_sanitized(login_env, monkeypatch, content): - from runpod.apps.auth import pending_agent_login_path + from runpod.auth.login import pending_agent_login_path pending_agent_login_path("default").write_text(content) verify = AsyncMock() - monkeypatch.setattr("runpod.apps.auth.verify_agent_login", verify) + monkeypatch.setattr("runpod.auth.login.verify_agent_login", verify) result = CliRunner().invoke(cli, ["login", "--agent", "--code", "012345"]) assert result.exit_code == 1 assert "invalid pending login" in result.output @@ -275,7 +275,7 @@ def test_two_step_invalid_state_is_sanitized(login_env, monkeypatch, content): def test_pending_logins_are_private_and_profile_scoped(login_env): - from runpod.apps.auth import ( + from runpod.auth.login import ( load_agent_login, pending_agent_login_path, save_agent_login, @@ -296,7 +296,7 @@ def test_pending_logins_are_private_and_profile_scoped(login_env): def test_two_step_api_change_does_not_send_verifier(login_env, monkeypatch): - from runpod.apps.auth import save_agent_login + from runpod.auth.login import save_agent_login save_agent_login( { @@ -308,7 +308,7 @@ def test_two_step_api_change_does_not_send_verifier(login_env, monkeypatch): ) monkeypatch.setenv("RUNPOD_API_BASE_URL", "https://api.runpod.io") post = AsyncMock() - monkeypatch.setattr("runpod.apps.auth._post_authentication_attempt", post) + monkeypatch.setattr("runpod.auth.login._post_authentication_attempt", post) result = CliRunner().invoke(cli, ["login", "--agent", "--code", "012345"]) assert result.exit_code == 1 assert "different API" in result.output @@ -349,7 +349,7 @@ def test_email_request_prints_shell_safe_completion_command(login_env, profile): def test_pending_login_atomic_write_preserves_previous_attempt(login_env, monkeypatch): - from runpod.apps.auth import ( + from runpod.auth.login import ( load_agent_login, pending_agent_login_path, save_agent_login, @@ -362,7 +362,7 @@ def test_pending_login_atomic_write_preserves_previous_attempt(login_env, monkey } save_agent_login(attempt, "default") monkeypatch.setattr( - "runpod.apps.auth.os.replace", MagicMock(side_effect=OSError("disk full")) + "runpod.auth.login.os.replace", MagicMock(side_effect=OSError("disk full")) ) with pytest.raises(OSError, match="disk full"): save_agent_login({**attempt, "attempt_id": "att_new"}, "default") @@ -373,7 +373,7 @@ def test_pending_login_atomic_write_preserves_previous_attempt(login_env, monkey def test_two_step_credential_write_failure_keeps_pending_state(login_env, monkeypatch): - from runpod.apps.auth import load_agent_login, save_agent_login + from runpod.auth.login import load_agent_login, save_agent_login attempt = { "attempt_id": "att_test", @@ -382,7 +382,7 @@ def test_two_step_credential_write_failure_keeps_pending_state(login_env, monkey } save_agent_login(attempt, "default") monkeypatch.setattr( - "runpod.apps.auth.verify_agent_login", AsyncMock(return_value="rpa_test") + "runpod.auth.login.verify_agent_login", AsyncMock(return_value="rpa_test") ) monkeypatch.setattr( functions, "set_credentials", MagicMock(side_effect=OSError("disk full")) diff --git a/tests/test_cli/test_catalog_command.py b/tests/test_cli/test_catalog_command.py index 70ede1d45..38a805d62 100644 --- a/tests/test_cli/test_catalog_command.py +++ b/tests/test_cli/test_catalog_command.py @@ -7,7 +7,7 @@ from click.testing import CliRunner from runpod import error -from runpod.rp_cli.main import cli +from runpod.cli.main import cli GPUS = [ { @@ -88,16 +88,16 @@ @pytest.fixture(autouse=True) def wide_console(monkeypatch): - from runpod.rp_cli import console as ui + from runpod.cli import console as ui monkeypatch.setattr(ui.console, "_width", 200) def _invoke(args, gpus=GPUS, cpus=CPUS, datacenters=DATACENTERS): with ( - patch("runpod.rp_cli.compute.list_gpus", return_value=gpus) as list_gpus, - patch("runpod.rp_cli.compute.list_cpus", return_value=cpus) as list_cpus, - patch("runpod.rp_cli.compute.list_datacenters", return_value=datacenters), + patch("runpod.cli.compute.list_gpus", return_value=gpus) as list_gpus, + patch("runpod.cli.compute.list_cpus", return_value=cpus) as list_cpus, + patch("runpod.cli.compute.list_datacenters", return_value=datacenters), ): result = CliRunner().invoke(cli, ["catalog", *args]) return result, list_gpus, list_cpus @@ -108,7 +108,7 @@ class TestGpuCatalog: "cloud, expected", [(None, 10), ("secure", 1), ("community", 10)] ) def test_max_count_matches_cloud(self, cloud, expected): - from runpod.rp_cli.catalog import _gpu_columns + from runpod.cli.catalog import _gpu_columns columns = dict(_gpu_columns("POD", 1, cloud)) assert columns["MAX"](GPUS[1]) == expected @@ -209,7 +209,7 @@ def test_conflicting_flags(self): def test_api_error_is_clean(self): with patch( - "runpod.rp_cli.compute.list_gpus", + "runpod.cli.compute.list_gpus", side_effect=error.AuthenticationError("Unauthorized request"), ): result = CliRunner().invoke(cli, ["catalog"]) @@ -249,7 +249,7 @@ def test_unknown(self): ], ) def test_per_vcpu_price_precision(self, product, price, expected): - from runpod.rp_cli.catalog import _cpu_columns + from runpod.cli.catalog import _cpu_columns tier = "serverlessPerVcpu" if product == "SERVERLESS" else "securePerVcpu" row = dict(CPUS[0], price={tier: price}) @@ -285,9 +285,9 @@ def test_per_vcpu_price_precision(self, product, price, expected): ) def test_inapplicable_flags_fail_before_fetch(mode, options, offending_flag, as_json): with ( - patch("runpod.rp_cli.compute.list_datacenters") as list_datacenters, - patch("runpod.rp_cli.compute.list_gpus") as list_gpus, - patch("runpod.rp_cli.compute.list_cpus") as list_cpus, + patch("runpod.cli.compute.list_datacenters") as list_datacenters, + patch("runpod.cli.compute.list_gpus") as list_gpus, + patch("runpod.cli.compute.list_cpus") as list_cpus, ): result = CliRunner().invoke( cli, ["catalog", *mode, *options, *(["--json"] if as_json else [])] diff --git a/tests/test_cli/test_cli_api.py b/tests/test_cli/test_cli_api.py index 30bdf537e..a650cbe72 100644 --- a/tests/test_cli/test_cli_api.py +++ b/tests/test_cli/test_cli_api.py @@ -7,7 +7,7 @@ import requests from runpod import error -from runpod.rp_cli import api +from runpod.cli import api class TestApi: diff --git a/tests/test_cli/test_cli_groups/test_ssh_dispatch.py b/tests/test_cli/test_cli_groups/test_ssh_dispatch.py index fa74cc130..57e2648ba 100644 --- a/tests/test_cli/test_cli_groups/test_ssh_dispatch.py +++ b/tests/test_cli/test_cli_groups/test_ssh_dispatch.py @@ -4,7 +4,7 @@ from click.testing import CliRunner -from runpod.rp_cli.main import cli +from runpod.cli.main import cli class TestSSHDispatch: diff --git a/tests/test_cli/test_cli_logs.py b/tests/test_cli/test_cli_logs.py index be703564d..fa6930dfd 100644 --- a/tests/test_cli/test_cli_logs.py +++ b/tests/test_cli/test_cli_logs.py @@ -5,7 +5,7 @@ import pytest from runpod.apps.errors import AppHTTPError -from runpod.rp_cli import logs +from runpod.cli import logs def event(line="hello", ts="2026-01-01T00:00:00Z"): diff --git a/tests/test_cli/test_cli_options.py b/tests/test_cli/test_cli_options.py index 6587bc953..e9c55f389 100644 --- a/tests/test_cli/test_cli_options.py +++ b/tests/test_cli/test_cli_options.py @@ -3,8 +3,8 @@ import click import pytest -from runpod.rp_cli.compute import ResolutionError -from runpod.rp_cli.options import container_fields, parse_env +from runpod.cli.compute import ResolutionError +from runpod.cli.options import container_fields, parse_env def test_env_values_preserve_equals_and_allow_empty_values(): @@ -64,7 +64,7 @@ def list_registries(path, collection): assert (path, collection) == ("/v2/registries", "registries") return [{"id": "reg1", "name": "private"}] - monkeypatch.setattr("runpod.rp_cli.options.list_all", list_registries) + monkeypatch.setattr("runpod.cli.options.list_all", list_registries) assert container_fields({"registry": registry}) == {"registry": "reg1"} @@ -72,12 +72,12 @@ def test_container_fields_clear_registry_without_lookup(monkeypatch): def unexpected_lookup(*args): pytest.fail("clearing a registry must not fetch credentials") - monkeypatch.setattr("runpod.rp_cli.options.list_all", unexpected_lookup) + monkeypatch.setattr("runpod.cli.options.list_all", unexpected_lookup) assert container_fields({"registry": ""}) == {"registry": None} def test_container_fields_reject_unknown_registry(monkeypatch): - monkeypatch.setattr("runpod.rp_cli.options.list_all", lambda *args: []) + monkeypatch.setattr("runpod.cli.options.list_all", lambda *args: []) with pytest.raises(ResolutionError, match="unknown registry credential"): container_fields({"registry": "missing"}) diff --git a/tests/test_cli/test_cli_output.py b/tests/test_cli/test_cli_output.py index 22260e9f7..1bfbd706a 100644 --- a/tests/test_cli/test_cli_output.py +++ b/tests/test_cli/test_cli_output.py @@ -6,7 +6,7 @@ import pytest from runpod import error -from runpod.rp_cli import output +from runpod.cli import output class TestOutputHelpers: @@ -17,7 +17,7 @@ def test_cell(self): assert output.cell(3) == "3" def test_print_table_keeps_ids_and_values_whole(self, monkeypatch, capsys): - from runpod.rp_cli import console as ui + from runpod.cli import console as ui monkeypatch.setattr(ui.console, "_width", 40) rows = [{"id": "cmvfsn771000007jp15tn8esm", "type": "high_performance"}] diff --git a/tests/test_cli/test_compute.py b/tests/test_cli/test_compute.py index d7124b4c8..2376e493b 100644 --- a/tests/test_cli/test_compute.py +++ b/tests/test_cli/test_compute.py @@ -4,7 +4,7 @@ import pytest -from runpod.rp_cli import compute +from runpod.cli import compute GPUS = [ {"id": "NVIDIA GeForce RTX 4090", "name": "RTX 4090", "pool": "ADA_24"}, diff --git a/tests/test_cli/test_console.py b/tests/test_cli/test_console.py index 6a1027030..307870e37 100644 --- a/tests/test_cli/test_console.py +++ b/tests/test_cli/test_console.py @@ -5,7 +5,7 @@ import pytest from rich.console import Console -from runpod.rp_cli import console as ui +from runpod.cli import console as ui @pytest.fixture(autouse=True) diff --git a/tests/test_cli/test_deploy_command.py b/tests/test_cli/test_deploy_command.py index f16b5df44..a3ee19ad2 100644 --- a/tests/test_cli/test_deploy_command.py +++ b/tests/test_cli/test_deploy_command.py @@ -7,7 +7,7 @@ from click.testing import CliRunner from runpod.apps.deploy import DeployResult -from runpod.rp_cli.main import cli +from runpod.cli.main import cli from runpod.apps.utils.names import dev_endpoint_name diff --git a/tests/test_cli/test_endpoint_command.py b/tests/test_cli/test_endpoint_command.py index 3c9631e20..734f1e97f 100644 --- a/tests/test_cli/test_endpoint_command.py +++ b/tests/test_cli/test_endpoint_command.py @@ -9,9 +9,9 @@ from runpod import error from runpod.endpoint import runner -from runpod.rp_cli import api as cli_api, compute, endpoint_config as config, output -from runpod.rp_cli import endpoint as ep -from runpod.rp_cli.main import cli +from runpod.cli import api as cli_api, compute, endpoint_config as config, output +from runpod.cli import endpoint as ep +from runpod.cli.main import cli PAGE = {"hasNextPage": False, "nextCursor": None} @@ -192,7 +192,7 @@ def no_network(*args, **kwargs): pytest.fail("endpoint tests must not make real network requests") monkeypatch.setattr(requests.sessions.Session, "request", no_network) - from runpod.rp_cli import console as ui + from runpod.cli import console as ui monkeypatch.setattr(ui.console, "_width", 200) @@ -952,7 +952,7 @@ def test_releases(api): def test_logs_routes_options_to_shared_streamer(api, monkeypatch): - from runpod.rp_cli import logs + from runpod.cli import logs show = MagicMock() monkeypatch.setattr(logs, "show_logs", show) diff --git a/tests/test_cli/test_init_command.py b/tests/test_cli/test_init_command.py index 42be0898c..fe1af3146 100644 --- a/tests/test_cli/test_init_command.py +++ b/tests/test_cli/test_init_command.py @@ -3,7 +3,7 @@ from click.testing import CliRunner from runpod.apps.init import create_project, detect_conflicts -from runpod.rp_cli.main import cli +from runpod.cli.main import cli class TestCreateProject: diff --git a/tests/test_cli/test_management_commands.py b/tests/test_cli/test_management_commands.py index 67f2e4784..4c8e91b23 100644 --- a/tests/test_cli/test_management_commands.py +++ b/tests/test_cli/test_management_commands.py @@ -7,7 +7,7 @@ from click.testing import CliRunner from runpod.apps.manage import UndeployResult -from runpod.rp_cli.main import cli +from runpod.cli.main import cli def _runner(): @@ -352,7 +352,7 @@ class TestLoginCommand: def test_login_updates_only_selected_profile( self, tmp_path, monkeypatch, browser, profile ): - from runpod.cli.groups.config import functions + from runpod.auth import credentials as functions credentials = tmp_path / "config.toml" credentials.write_text( @@ -361,13 +361,13 @@ def test_login_updates_only_selected_profile( '[production]\napi_key = "keep-production"\n' ) monkeypatch.setattr(functions, "CREDENTIAL_FILE", str(credentials)) - monkeypatch.setattr("runpod.rp_cli.main._stdin_is_tty", lambda: True) + monkeypatch.setattr("runpod.cli.main._stdin_is_tty", lambda: True) args = ["login"] if profile != "default": args.extend(["--profile", profile]) args.extend(["--no-open"] if browser else ["--api-key", "new-key"]) with patch( - "runpod.apps.auth.browser_login", AsyncMock(return_value="new-key") + "runpod.auth.login.browser_login", AsyncMock(return_value="new-key") ): result = _runner().invoke(cli, args) @@ -378,7 +378,7 @@ def test_login_updates_only_selected_profile( assert functions.get_credentials("production")["api_key"] == "keep-production" def test_login_saves_to_profile_from_env(self, tmp_path, monkeypatch): - from runpod.cli.groups.config import functions + from runpod.auth import credentials as functions credentials = tmp_path / "config.toml" credentials.write_text('[default]\napi_key = "keep-default"\n') @@ -392,7 +392,7 @@ def test_login_saves_to_profile_from_env(self, tmp_path, monkeypatch): assert functions.get_credentials("default")["api_key"] == "keep-default" def test_login_profile_flag_overrides_env(self, tmp_path, monkeypatch): - from runpod.cli.groups.config import functions + from runpod.auth import credentials as functions credentials = tmp_path / "config.toml" monkeypatch.setattr(functions, "CREDENTIAL_FILE", str(credentials)) @@ -407,12 +407,12 @@ def test_login_profile_flag_overrides_env(self, tmp_path, monkeypatch): assert functions.get_credentials("team") is None def test_browser_flow_error(self): - from runpod.apps.auth import LoginError + from runpod.auth.login import LoginError with ( - patch("runpod.rp_cli.main._stdin_is_tty", return_value=True), + patch("runpod.cli.main._stdin_is_tty", return_value=True), patch( - "runpod.apps.auth.browser_login", + "runpod.auth.login.browser_login", AsyncMock(side_effect=LoginError("api key was rejected")), ), ): @@ -422,24 +422,24 @@ def test_browser_flow_error(self): def test_browser_flow_fails_fast_without_tty(self): login = AsyncMock() - with patch("runpod.apps.auth.browser_login", login): + with patch("runpod.auth.login.browser_login", login): result = _runner().invoke(cli, ["login", "--no-open"]) assert result.exit_code == 1 assert "RUNPOD_API_KEY" in result.output login.assert_not_called() def test_browser_flow_prompts_with_hidden_input(self, tmp_path, monkeypatch): - from runpod.cli.groups.config import functions + from runpod.auth import credentials as functions monkeypatch.setattr(functions, "CREDENTIAL_FILE", str(tmp_path / "c.toml")) api = MagicMock() api.create_auth_request = AsyncMock(return_value={"id": "req-1"}) api.verify_api_key = AsyncMock(return_value=True) with ( - patch("runpod.rp_cli.main._stdin_is_tty", return_value=True), - patch("runpod.apps.auth.AppsApiClient", return_value=api), + patch("runpod.cli.main._stdin_is_tty", return_value=True), + patch("runpod.auth.login.AuthApiClient", return_value=api), patch( - "runpod.rp_cli.main.click.prompt", return_value=" rpa_new " + "runpod.cli.main.click.prompt", return_value=" rpa_new " ) as prompt, ): result = _runner().invoke(cli, ["login", "--no-open"]) diff --git a/tests/test_cli/test_pod_command.py b/tests/test_cli/test_pod_command.py index b33498a12..02d235d5f 100644 --- a/tests/test_cli/test_pod_command.py +++ b/tests/test_cli/test_pod_command.py @@ -7,8 +7,8 @@ from click.testing import CliRunner from runpod import error -from runpod.rp_cli import pod as pod_module -from runpod.rp_cli.main import cli +from runpod.cli import pod as pod_module +from runpod.cli.main import cli GPUS = [ { @@ -170,12 +170,12 @@ def made(self, method, path): @pytest.fixture(autouse=True) def cli_environment(monkeypatch): - from runpod.rp_cli import console as ui + from runpod.cli import console as ui monkeypatch.setattr(ui.console, "_width", 200) monkeypatch.setattr(pod_module.time, "sleep", lambda seconds: None) monkeypatch.setattr( - "requests.request", + "requests.Session.request", MagicMock(side_effect=AssertionError("unexpected HTTP request")), ) @@ -183,13 +183,13 @@ def cli_environment(monkeypatch): def _invoke(args, api=None, gpus=GPUS, interactive=False, input=None): api = api or FakeApi() with ( - patch("runpod.rp_cli.pod.run_rest_request", api), - patch("runpod.rp_cli.api.run_rest_request", api), - patch("runpod.rp_cli.compute.list_gpus", return_value=gpus) as list_gpus, - patch("runpod.rp_cli.compute.list_cpus", return_value=CPUS) as list_cpus, - patch("runpod.rp_cli.compute.list_datacenters", return_value=DATACENTERS), - patch("runpod.rp_cli.pod.interactive", return_value=interactive), - patch("runpod.rp_cli.output.interactive", return_value=interactive), + patch("runpod.cli.pod.run_rest_request", api), + patch("runpod.cli.api.run_rest_request", api), + patch("runpod.cli.compute.list_gpus", return_value=gpus) as list_gpus, + patch("runpod.cli.compute.list_cpus", return_value=CPUS) as list_cpus, + patch("runpod.cli.compute.list_datacenters", return_value=DATACENTERS), + patch("runpod.cli.pod.interactive", return_value=interactive), + patch("runpod.cli.output.interactive", return_value=interactive), ): result = CliRunner().invoke(cli, ["pod", *args], input=input) result.api, result.list_gpus, result.list_cpus = api, list_gpus, list_cpus @@ -878,14 +878,14 @@ def test_sync_is_mounted(self): ], ) def test_logs_forward_options(args, expected): - with patch("runpod.rp_cli.logs.show_logs") as show_logs: + with patch("runpod.cli.logs.show_logs") as show_logs: result = _invoke(["logs", "pod123", *args]) assert result.exit_code == 0, result.output show_logs.assert_called_once_with("pod123", **expected) def test_logs_reject_tail_above_api_limit(): - with patch("runpod.rp_cli.logs.show_logs") as show_logs: + with patch("runpod.cli.logs.show_logs") as show_logs: result = _invoke(["logs", "pod123", "--tail", "5001"]) assert result.exit_code == 2 assert "5000" in result.output @@ -896,9 +896,9 @@ class TestCompletion: def test_completers(self): api = FakeApi() with ( - patch("runpod.rp_cli.pod.run_rest_request", api), - patch("runpod.rp_cli.api.run_rest_request", api), - patch("runpod.rp_cli.compute.list_datacenters", return_value=DATACENTERS), + patch("runpod.cli.pod.run_rest_request", api), + patch("runpod.cli.api.run_rest_request", api), + patch("runpod.cli.compute.list_datacenters", return_value=DATACENTERS), ): pods = pod_module._complete_pods(None, None, "pod1") datacenters = pod_module._complete_datacenters(None, None, "EU") diff --git a/tests/test_cli/test_project_commands.py b/tests/test_cli/test_project_commands.py index 8221f344a..eebed2f13 100644 --- a/tests/test_cli/test_project_commands.py +++ b/tests/test_cli/test_project_commands.py @@ -9,7 +9,7 @@ from runpod.apps.app import _clear_registry, get_registered_apps from runpod.apps.entrypoint import _clear_entrypoints, get_entrypoints -from runpod.rp_cli.main import cli +from runpod.cli.main import cli APP_SOURCE = """ import runpod @@ -31,7 +31,7 @@ def clean_project_state(tmp_path, monkeypatch): _clear_registry() _clear_entrypoints() monkeypatch.delenv("RUNPOD_DEV_SESSION", raising=False) - monkeypatch.setattr("runpod.rp_cli.update.start_background_check", lambda: None) + monkeypatch.setattr("runpod.cli.update.start_background_check", lambda: None) yield _clear_registry() _clear_entrypoints() diff --git a/tests/test_cli/test_stream_encoding.py b/tests/test_cli/test_stream_encoding.py index 2779f7863..48edbd93b 100644 --- a/tests/test_cli/test_stream_encoding.py +++ b/tests/test_cli/test_stream_encoding.py @@ -8,7 +8,7 @@ import pytest -from runpod.rp_cli import main +from runpod.cli import main @pytest.mark.parametrize("encoding", ["cp1252", "ascii", "utf-8"]) @@ -25,7 +25,7 @@ def test_redirected_deploy_output(tmp_path, encoding, destination, build_only): from unittest.mock import patch from runpod.apps.deploy import DeployResult - from runpod.rp_cli.main import run + from runpod.cli.main import run def build(app, root, *, events, output, **kwargs): events.phase("package") @@ -46,7 +46,7 @@ async def deploy(app, root, *, events, **kwargs): with ( patch("runpod.apps.deploy.build_artifact", side_effect=build), patch("runpod.apps.deploy.deploy_app", side_effect=deploy), - patch("runpod.rp_cli.update.start_background_check"), + patch("runpod.cli.update.start_background_check"), ): run() """) diff --git a/tests/test_cli/test_update_command.py b/tests/test_cli/test_update_command.py index ed3eb8dbb..62288c0fb 100644 --- a/tests/test_cli/test_update_command.py +++ b/tests/test_cli/test_update_command.py @@ -7,8 +7,8 @@ import pytest from click.testing import CliRunner -from runpod.rp_cli import update as upd -from runpod.rp_cli.main import cli +from runpod.cli import update as upd +from runpod.cli.main import cli class TestParseVersion: @@ -50,7 +50,7 @@ def test_already_current(self): with patch.object( upd, "fetch_pypi_metadata", return_value=("9.9.9", {"9.9.9"}) ), patch.object(upd, "current_version", return_value="9.9.9"), patch( - "runpod.rp_cli.main.cli.callback" + "runpod.cli.main.cli.callback" ): result = runner.invoke(cli, ["update"]) assert result.exit_code == 0, result.output diff --git a/tests/test_cli/test_volume_command.py b/tests/test_cli/test_volume_command.py index 40a4d1dcf..71c922701 100644 --- a/tests/test_cli/test_volume_command.py +++ b/tests/test_cli/test_volume_command.py @@ -6,7 +6,7 @@ from click.testing import CliRunner from runpod import error -from runpod.rp_cli.main import cli +from runpod.cli.main import cli VOLUME = { "id": "vol1", @@ -40,20 +40,20 @@ def invoke(command, **kwargs): @pytest.fixture def rest(): - with patch("runpod.rp_cli.volume.run_rest_request", return_value=VOLUME) as mock: + with patch("runpod.cli.volume.run_rest_request", return_value=VOLUME) as mock: yield mock @pytest.fixture def listing(): - with patch("runpod.rp_cli.volume.list_all", return_value=[VOLUME]) as mock: + with patch("runpod.cli.volume.list_all", return_value=[VOLUME]) as mock: yield mock @pytest.fixture def datacenters(): with patch( - "runpod.rp_cli.compute.list_datacenters", return_value=DATACENTERS + "runpod.cli.compute.list_datacenters", return_value=DATACENTERS ) as mock: yield mock @@ -100,7 +100,7 @@ def test_get_fields_and_json(resource, rest): def test_get_picker(rest, listing): - with patch("runpod.rp_cli.volume.pick", return_value="vol1") as pick: + with patch("runpod.cli.volume.pick", return_value="vol1") as pick: result = invoke("get") assert result.exit_code == 0, result.output assert pick.call_args.args[1] == [("vol1", "models 100 GB EU-RO-1 standard")] @@ -160,7 +160,7 @@ def test_create_exact_data_center(rest, datacenters): ], ) def test_create_filters_picker_candidates(rest, datacenters, options, candidates): - with patch("runpod.rp_cli.volume.pick", return_value=candidates[0]) as pick: + with patch("runpod.cli.volume.pick", return_value=candidates[0]) as pick: result = invoke(f"create --name m --size 10 {options} --json") assert result.exit_code == 0, result.output assert [value for value, _ in pick.call_args.args[1]] == candidates @@ -303,7 +303,7 @@ def test_delete_yes(resource, rest): @pytest.mark.parametrize("answer,code", [("y", 0), ("n", 1)]) def test_delete_confirmation(rest, answer, code): - with patch("runpod.rp_cli.output.interactive", return_value=True): + with patch("runpod.cli.output.interactive", return_value=True): result = invoke("delete vol1", input=f"{answer}\n") assert result.exit_code == code assert "models 100 GB EU-RO-1 standard" in result.output diff --git a/tests/test_endpoint/test_asyncio_runner.py b/tests/test_endpoint/test_asyncio_runner.py index 0312df89f..e2d6d3e20 100644 --- a/tests/test_endpoint/test_asyncio_runner.py +++ b/tests/test_endpoint/test_asyncio_runner.py @@ -26,14 +26,14 @@ async def test_status(self): Tests Job.status """ with patch( - "aiohttp.ClientSession", new_callable=AsyncMock + "aiohttp.ClientSession", new_callable=MagicMock ) as mock_session_class: mock_session = mock_session_class.return_value - mock_get = mock_session.get + mock_get = mock_session.request mock_resp = AsyncMock() mock_resp.json.return_value = {"status": "COMPLETED"} - mock_get.return_value = mock_resp + mock_get.return_value.__aenter__.return_value = mock_resp headers = { "Content-Type": "application/json", @@ -52,10 +52,10 @@ async def test_output(self): with patch( "runpod.endpoint.asyncio.asyncio_runner.asyncio.sleep" ) as mock_sleep, patch( - "aiohttp.ClientSession", new_callable=AsyncMock + "aiohttp.ClientSession", new_callable=MagicMock ) as mock_session_class: mock_session = mock_session_class.return_value - mock_get = mock_session.get + mock_get = mock_session.request mock_resp = AsyncMock() async def json_side_effect(): @@ -64,7 +64,7 @@ async def json_side_effect(): return {"output": "OUTPUT", "status": "COMPLETED"} mock_resp.json.side_effect = json_side_effect - mock_get.return_value = mock_resp + mock_get.return_value.__aenter__.return_value = mock_resp headers = { "Content-Type": "application/json", @@ -83,14 +83,14 @@ async def test_output_timeout(self): Tests Job.output with a timeout """ with patch( - "aiohttp.ClientSession", new_callable=AsyncMock + "aiohttp.ClientSession", new_callable=MagicMock ) as mock_session_class: mock_session = mock_session_class.return_value - mock_get = mock_session.get + mock_get = mock_session.request mock_resp = AsyncMock() mock_resp.json.return_value = {"status": "IN_PROGRESS"} - mock_get.return_value = mock_resp + mock_get.return_value.__aenter__.return_value = mock_resp headers = { "Content-Type": "application/json", @@ -108,10 +108,10 @@ async def test_stream(self): Tests Job.stream """ with patch( - "aiohttp.ClientSession", new_callable=AsyncMock + "aiohttp.ClientSession", new_callable=MagicMock ) as mock_session_class: mock_session = mock_session_class.return_value - mock_get = mock_session.get + mock_get = mock_session.request mock_resp = AsyncMock() responses = [ @@ -127,7 +127,7 @@ async def json_side_effect(): ) mock_resp.json.side_effect = json_side_effect - mock_get.return_value = mock_resp + mock_get.return_value.__aenter__.return_value = mock_resp headers = { "Content-Type": "application/json", @@ -146,10 +146,10 @@ async def test_output_after_stream_fetches_aggregate_result(self): """output() after a completed stream fetches the aggregate result from /status instead of returning the stream's empty output.""" with patch( - "aiohttp.ClientSession", new_callable=AsyncMock + "aiohttp.ClientSession", new_callable=MagicMock ) as mock_session_class: mock_session = mock_session_class.return_value - mock_get = mock_session.get + mock_get = mock_session.request mock_resp = AsyncMock() responses = [ @@ -165,7 +165,7 @@ async def json_side_effect(): } mock_resp.json.side_effect = json_side_effect - mock_get.return_value = mock_resp + mock_get.return_value.__aenter__.return_value = mock_resp headers = { "Content-Type": "application/json", @@ -186,7 +186,7 @@ async def test_cancel(self): mock_resp = MagicMock() mock_resp.json = MagicMock(return_value=asyncio.Future()) mock_resp.json.return_value.set_result({"result": "CANCELLED"}) - mock_session.post.return_value.__aenter__.return_value = mock_resp + mock_session.request.return_value.__aenter__.return_value = mock_resp headers = { "Content-Type": "application/json", @@ -200,10 +200,10 @@ async def test_cancel(self): async def test_output_in_progress_then_completed(self): """Tests Job.output when status is initially IN_PROGRESS and then changes to COMPLETED""" with patch( - "aiohttp.ClientSession", new_callable=AsyncMock + "aiohttp.ClientSession", new_callable=MagicMock ) as mock_session_class: mock_session = mock_session_class.return_value - mock_get = mock_session.get + mock_get = mock_session.request mock_resp = AsyncMock() responses = [ @@ -219,7 +219,7 @@ async def json_side_effect(): ) # pylint: disable=line-too-long mock_resp.json.side_effect = json_side_effect - mock_get.return_value = mock_resp + mock_get.return_value.__aenter__.return_value = mock_resp headers = { "Content-Type": "application/json", @@ -247,7 +247,7 @@ async def test_run(self): mock_resp = MagicMock() mock_resp.json = MagicMock(return_value=asyncio.Future()) mock_resp.json.return_value.set_result({"id": "job_id"}) - mock_session.post.return_value.__aenter__.return_value = mock_resp + mock_session.request.return_value.__aenter__.return_value = mock_resp endpoint = Endpoint("endpoint_id", mock_session) job = await endpoint.run({"input": "INPUT"}) @@ -261,7 +261,7 @@ async def test_health(self): mock_resp = MagicMock() mock_resp.json = MagicMock(return_value=asyncio.Future()) mock_resp.json.return_value.set_result({"status": "HEALTHY"}) - mock_session.get.return_value.__aenter__.return_value = mock_resp + mock_session.request.return_value.__aenter__.return_value = mock_resp endpoint = Endpoint("endpoint_id", mock_session) health = await endpoint.health() @@ -275,7 +275,7 @@ async def test_purge_queue(self): mock_resp = MagicMock() mock_resp.json = MagicMock(return_value=asyncio.Future()) mock_resp.json.return_value.set_result({"result": "PURGED"}) - mock_session.post.return_value.__aenter__.return_value = mock_resp + mock_session.request.return_value.__aenter__.return_value = mock_resp endpoint = Endpoint("endpoint_id", mock_session) purge_result = await endpoint.purge_queue() diff --git a/tests/test_endpoint/test_failed_jobs.py b/tests/test_endpoint/test_failed_jobs.py index b87f288bc..f0ace1995 100644 --- a/tests/test_endpoint/test_failed_jobs.py +++ b/tests/test_endpoint/test_failed_jobs.py @@ -1,6 +1,6 @@ """a job that ends in a non-COMPLETED final state raises JobError.""" -from unittest.mock import AsyncMock, Mock, patch +from unittest.mock import AsyncMock, MagicMock, Mock, patch import pytest @@ -79,8 +79,8 @@ def test_job_error_without_error_field_still_names_the_status(): async def test_async_job_output_raises_on_failure(): response = AsyncMock() response.json.return_value = {"status": "FAILED", "error": "bad input"} - session = AsyncMock() - session.get.return_value = response + session = MagicMock() + session.request.return_value.__aenter__.return_value = response job = AsyncJob("ENDPOINT_ID", "job-1", session, headers={}) with pytest.raises(JobError, match="bad input") as caught: diff --git a/tests/test_endpoint/test_transport.py b/tests/test_endpoint/test_transport.py new file mode 100644 index 000000000..f9bfa81dd --- /dev/null +++ b/tests/test_endpoint/test_transport.py @@ -0,0 +1,221 @@ +"""Endpoint route, response lifetime, and session ownership tests.""" + +import asyncio +from unittest.mock import AsyncMock, MagicMock, Mock, patch + +import aiohttp +import pytest +import requests + +import runpod +from runpod.endpoint.asyncio import asyncio_runner +from runpod.endpoint.helpers import UNAUTHORIZED_MSG +from runpod.endpoint.runner import Endpoint, Job, RunPodClient + + +@pytest.mark.parametrize( + ("operation", "method", "path", "timeout"), + [ + ("run", "POST", "run", 10), + ("run_sync", "POST", "runsync", 86400), + ("health", "GET", "health", 3), + ("purge_queue", "POST", "purge-queue", 3), + ("status", "GET", "status/job%2F%3F%23%25", 10), + ("stream", "GET", "stream/job%2F%3F%23%25", 10), + ("cancel", "POST", "cancel/job%2F%3F%23%25", 3), + ], +) +def test_sync_routes_and_response_release(operation, method, path, timeout): + response = Mock(status_code=200) + response.json.return_value = {"id": "job/?#%", "status": "COMPLETED"} + with ( + patch.object(runpod, "endpoint_url_base", "https://example.com/v2/"), + patch("requests.Session.request", return_value=response) as request, + ): + with Endpoint("endpoint/?#%", api_key="endpoint-key") as endpoint: + if operation in {"run", "run_sync"}: + getattr(endpoint, operation)({"message": "hello"}) + elif operation in {"health", "purge_queue"}: + getattr(endpoint, operation)() + else: + job = Job(endpoint.endpoint_id, "job/?#%", endpoint.rp_client) + if operation == "stream": + job._fetch_job("stream") + else: + getattr(job, operation)() + + assert request.call_args.args == ( + method, + f"https://example.com/v2/endpoint%2F%3F%23%25/{path}", + ) + assert request.call_args.kwargs["headers"]["Authorization"] == "Bearer endpoint-key" + assert request.call_args.kwargs["timeout"] == timeout + assert request.call_args.kwargs["allow_redirects"] is False + response.close.assert_called_once_with() + + +def test_sync_endpoint_reuses_and_closes_its_pool(): + session = Mock() + session.request.return_value.status_code = 200 + session.request.return_value.json.return_value = { + "id": "job", + "status": "COMPLETED", + } + with patch("runpod.endpoint.runner.requests.Session", return_value=session): + with Endpoint("endpoint", api_key="key") as endpoint: + job = endpoint.run({"message": "hello"}) + assert job.status() == "COMPLETED" + assert job.rp_client is endpoint.rp_client + assert endpoint.rp_client.rp_session is session + assert session.request.call_count == 2 + assert session.request.return_value.close.call_count == 2 + session.close.assert_not_called() + session.close.assert_called_once_with() + + +@pytest.mark.parametrize("failure", ["unauthorized", "http", "json"]) +def test_sync_releases_response_and_pool_on_errors(failure): + response = Mock(status_code=401 if failure == "unauthorized" else 500) + if failure == "http": + response.raise_for_status.side_effect = requests.HTTPError("server error") + expected = requests.HTTPError + message = "server error" + elif failure == "json": + response.status_code = 200 + response.json.side_effect = ValueError("invalid json") + expected = ValueError + message = "invalid json" + else: + expected = RuntimeError + message = UNAUTHORIZED_MSG + + with ( + patch("requests.Session.request", return_value=response), + patch("requests.Session.close") as close, + ): + with pytest.raises(expected) as error: + with RunPodClient(api_key="key") as client: + client.get("endpoint/status/job") + assert str(error.value) == message + close.assert_called_once_with() + response.close.assert_called_once_with() + + +@pytest.mark.asyncio +async def test_async_routes_reuse_the_borrowed_session(): + response = MagicMock() + response.json = AsyncMock( + return_value={"id": "job/?#%", "status": "COMPLETED", "output": "done"} + ) + context = MagicMock() + context.__aenter__.return_value = response + with patch.object(runpod, "endpoint_url_base", "https://example.com/v2/"): + timeout = aiohttp.ClientTimeout(total=900, connect=45, sock_read=120) + async with aiohttp.ClientSession(timeout=timeout) as session: + with patch.object(session, "request", return_value=context) as request: + endpoint = asyncio_runner.Endpoint( + "endpoint/?#%", session, api_key="key" + ) + job = await endpoint.run({"message": "hello"}) + await endpoint.health() + await endpoint.purge_queue() + assert await job.status() == "COMPLETED" + await job._fetch_job("stream") + await job.cancel() + assert job.session is session + assert not session.closed + + assert [ + (call.args[0], str(call.args[1])) for call in request.call_args_list + ] == [ + ("POST", "https://example.com/v2/endpoint%2F%3F%23%25/run"), + ("GET", "https://example.com/v2/endpoint%2F%3F%23%25/health"), + ("POST", "https://example.com/v2/endpoint%2F%3F%23%25/purge-queue"), + ( + "GET", + "https://example.com/v2/endpoint%2F%3F%23%25/status/job%2F%3F%23%25", + ), + ( + "GET", + "https://example.com/v2/endpoint%2F%3F%23%25/stream/job%2F%3F%23%25", + ), + ( + "POST", + "https://example.com/v2/endpoint%2F%3F%23%25/cancel/job%2F%3F%23%25", + ), + ] + for call in request.call_args_list: + assert call.kwargs["headers"]["Authorization"] == "Bearer key" + assert call.kwargs["timeout"] is timeout + assert call.kwargs["allow_redirects"] is False + assert request.call_args_list[0].kwargs["json"] == { + "input": {"message": "hello"} + } + assert request.call_args.kwargs["headers"]["X-Request-ID"] == "job/?#%" + assert context.__aexit__.await_count == 6 + response.raise_for_status.assert_not_called() + assert session.closed + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + "operation", ["run", "health", "purge_queue", "status", "cancel"] +) +async def test_async_json_errors_release_response_without_closing_session(operation): + response = MagicMock() + response.json = AsyncMock(side_effect=ValueError("invalid json")) + context = MagicMock() + context.__aenter__.return_value = response + async with aiohttp.ClientSession() as session: + with patch.object(session, "request", return_value=context): + endpoint = asyncio_runner.Endpoint("endpoint", session, api_key="key") + job = asyncio_runner.Job("endpoint", "job", session, endpoint.headers) + with pytest.raises(ValueError, match="invalid json"): + if operation == "run": + await endpoint.run({}) + elif operation in {"status", "cancel"}: + await getattr(job, operation)() + else: + await getattr(endpoint, operation)() + context.__aexit__.assert_awaited_once() + assert not session.closed + + +@pytest.mark.asyncio +@pytest.mark.parametrize("status", [401, 500]) +async def test_async_preserves_error_response_json(status): + response = MagicMock(status=status) + response.json = AsyncMock(return_value={"error": "request failed"}) + context = MagicMock() + context.__aenter__.return_value = response + async with aiohttp.ClientSession() as session: + with patch.object(session, "request", return_value=context): + endpoint = asyncio_runner.Endpoint("endpoint", session, api_key="key") + assert await endpoint.health() == {"error": "request failed"} + response.raise_for_status.assert_not_called() + context.__aexit__.assert_awaited_once() + assert not session.closed + + +@pytest.mark.asyncio +async def test_async_cancellation_releases_response_without_closing_session(): + decoding = asyncio.Event() + + async def read_json(): + decoding.set() + await asyncio.Future() + + response = MagicMock() + response.json = AsyncMock(side_effect=read_json) + context = MagicMock() + context.__aenter__.return_value = response + async with aiohttp.ClientSession() as session: + with patch.object(session, "request", return_value=context): + endpoint = asyncio_runner.Endpoint("endpoint", session, api_key="key") + task = asyncio.create_task(endpoint.run({})) + await decoding.wait() + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + context.__aexit__.assert_awaited_once() + assert not session.closed diff --git a/tests/test_network_volume_transfer.py b/tests/test_network_volume_transfer.py index 58cc2cde1..682127725 100644 --- a/tests/test_network_volume_transfer.py +++ b/tests/test_network_volume_transfer.py @@ -824,7 +824,7 @@ def test_no_module_level_transfer_exports(): @pytest.mark.usefixtures("cli_preflight") def test_cli_upload_prints_summary(tmp_path): - from runpod.rp_cli.main import cli + from runpod.cli.main import cli src = tmp_path / "f.txt" src.write_text("x") @@ -851,7 +851,7 @@ def fake_upload(volume, source, target, **kwargs): @pytest.mark.usefixtures("cli_preflight") def test_cli_download_failure_says_resume(): - from runpod.rp_cli.main import cli + from runpod.cli.main import cli with patch.object( runpod.NetworkVolume, "download", side_effect=ConnectionResetError("boom") @@ -864,7 +864,7 @@ def test_cli_download_failure_says_resume(): @pytest.mark.usefixtures("cli_preflight") def test_cli_ctrl_c_exits_130_with_resume_hint(): - from runpod.rp_cli.main import cli + from runpod.cli.main import cli with patch.object(runpod.NetworkVolume, "upload", side_effect=KeyboardInterrupt): result = CliRunner().invoke(cli, ["volume", "upload", "vol", "."]) @@ -874,7 +874,7 @@ def test_cli_ctrl_c_exits_130_with_resume_hint(): @pytest.mark.usefixtures("cli_preflight") def test_cli_final_error_has_no_resume_hint(): - from runpod.rp_cli.main import cli + from runpod.cli.main import cli err = nvt.NetworkVolumeTransferError("s3 api keys required") with patch.object(runpod.NetworkVolume, "download", side_effect=err): @@ -886,7 +886,7 @@ def test_cli_final_error_has_no_resume_hint(): @pytest.mark.usefixtures("cli_preflight") def test_cli_missing_path_has_no_resume_hint(): - from runpod.rp_cli.main import cli + from runpod.cli.main import cli with patch.object( runpod.NetworkVolume, "download", side_effect=FileNotFoundError("no such file") @@ -1338,14 +1338,14 @@ def test_download_refuses_symlinked_work_files(tmp_path, suffix): def _cli(): - from runpod.rp_cli.main import cli + from runpod.cli.main import cli return cli @pytest.fixture def interactive(monkeypatch): - monkeypatch.setattr("runpod.rp_cli.volume._interactive", lambda: True) + monkeypatch.setattr("runpod.cli.volume._interactive", lambda: True) @pytest.fixture @@ -1380,11 +1380,11 @@ def test_cli_offers_login_and_continues(monkeypatch, tmp_path, interactive): logins = [] monkeypatch.setattr(runpod, "api_key", None) monkeypatch.setattr( - "runpod.rp_cli.main.login", + "runpod.cli.main.login", _click.Command("login", callback=lambda **kw: logins.append(kw)), ) monkeypatch.setattr( - "runpod.cli.groups.config.functions.get_credentials", + "runpod.auth.credentials.get_credentials", lambda profile="default": {"api_key": "rpa_new"}, ) calls = [] @@ -1455,7 +1455,7 @@ def test_cli_prompts_for_keys_and_offers_to_save( monkeypatch.delenv(nvt.ACCESS_KEY_ENV) saved = [] monkeypatch.setattr( - "runpod.cli.groups.config.functions.set_s3_keys", + "runpod.auth.credentials.set_s3_keys", lambda access, secret, profile="default": saved.append((access, secret)), ) calls = [] @@ -1482,7 +1482,7 @@ def missing_volume(reference, **kwargs): monkeypatch.setattr(nvt, "_resolve_volume", missing_volume) monkeypatch.setattr( - "runpod.rp_cli.volume._prompt_s3_keys", lambda: pytest.fail("prompted for keys") + "runpod.cli.volume._prompt_s3_keys", lambda: pytest.fail("prompted for keys") ) result = CliRunner().invoke(_cli(), ["volume", "upload", "missing", str(tmp_path)]) assert result.exit_code == 1 @@ -1503,7 +1503,7 @@ def transfer(volume, source, target, **kwargs): monkeypatch.delenv(nvt.SECRET_KEY_ENV, raising=False) monkeypatch.setattr(nvt, "saved_s3_keys", lambda: ("saved", "old")) monkeypatch.setattr( - "runpod.rp_cli.volume._prompt_s3_keys", lambda: ("new", "secret") + "runpod.cli.volume._prompt_s3_keys", lambda: ("new", "secret") ) with patch.object( runpod.NetworkVolume, "upload", autospec=True, side_effect=transfer @@ -1547,8 +1547,8 @@ def transfer(volume, source, target, **kwargs): monkeypatch.delenv(nvt.ACCESS_KEY_ENV, raising=False) monkeypatch.delenv(nvt.SECRET_KEY_ENV, raising=False) monkeypatch.setattr(nvt, "saved_s3_keys", lambda: ("saved", "old")) - monkeypatch.setattr("runpod.rp_cli.volume._progress_bar", fake_bar) - monkeypatch.setattr("runpod.rp_cli.volume._prompt_s3_keys", prompt) + monkeypatch.setattr("runpod.cli.volume._progress_bar", fake_bar) + monkeypatch.setattr("runpod.cli.volume._prompt_s3_keys", prompt) with patch.object( runpod.NetworkVolume, "upload", autospec=True, side_effect=transfer ): @@ -1571,7 +1571,7 @@ def unsaved(): monkeypatch.delenv(nvt.ACCESS_KEY_ENV, raising=False) monkeypatch.delenv(nvt.SECRET_KEY_ENV, raising=False) monkeypatch.setattr(nvt, "saved_s3_keys", lambda: ("saved", "old")) - monkeypatch.setattr("runpod.rp_cli.volume._prompt_s3_keys", unsaved) + monkeypatch.setattr("runpod.cli.volume._prompt_s3_keys", unsaved) with patch.object( runpod.NetworkVolume, "upload", autospec=True, side_effect=transfer ): @@ -1664,7 +1664,7 @@ def make(volume, *args, location=None, **kwargs): def test_set_s3_keys_keeps_the_api_key_and_login_keeps_the_s3_keys( monkeypatch, tmp_path ): - from runpod.cli.groups.config import functions + from runpod.auth import credentials as functions monkeypatch.setattr(functions, "CREDENTIAL_FILE", str(tmp_path / "config.toml")) functions.set_credentials("rpa_one", overwrite=True) diff --git a/tests/test_profile.py b/tests/test_profile.py index 7751de035..282f4be5a 100644 --- a/tests/test_profile.py +++ b/tests/test_profile.py @@ -28,7 +28,7 @@ def test_blank_env_falls_back_to_default(self, monkeypatch, value): class TestApiKeyFromSelectedProfile: def test_loads_key_from_selected_profile(self, tmp_path, monkeypatch): - from runpod.cli.groups.config import functions + from runpod.auth import credentials as functions credentials = tmp_path / "config.toml" credentials.write_text( @@ -41,7 +41,7 @@ def test_loads_key_from_selected_profile(self, tmp_path, monkeypatch): assert runpod._load_api_key() == "team-key" def test_api_key_env_wins_over_profile(self, tmp_path, monkeypatch): - from runpod.cli.groups.config import functions + from runpod.auth import credentials as functions credentials = tmp_path / "config.toml" credentials.write_text('[team]\napi_key = "team-key"\n') @@ -63,7 +63,7 @@ def reload_runpod(self, monkeypatch): def test_s3_only_profile_imports_without_api_key( self, tmp_path, monkeypatch, reload_runpod ): - from runpod.cli.groups.config import functions + from runpod.auth import credentials as functions credentials = tmp_path / "config.toml" credentials.write_text( diff --git a/tests/test_shared/test_auth.py b/tests/test_shared/test_auth.py index 2cb93defb..b96b37118 100644 --- a/tests/test_shared/test_auth.py +++ b/tests/test_shared/test_auth.py @@ -18,7 +18,7 @@ class TestAPIKey(unittest.TestCase): """ @patch("builtins.open", new_callable=mock_open, read_data=CREDENTIALS) - @patch("runpod.cli.groups.config.functions.os.path.exists", return_value=True) + @patch("runpod.auth.credentials.os.path.exists", return_value=True) def test_use_file_credentials(self, _mock_exists, mock_file): """ Test that the API key is read from the credentials file