dataapp-resource-proxy 0.1.0__py3-none-any.whl

dataapp_resource_proxy/__init__.py

@@ -0,0 +1,15 @@
+"""Client for DataOS managed runtime resources."""
+
+from .client import ResourceProxy, ResourceTransport
+from .errors import ResourceProxyError
+from .handles import BrowserResource, CaptchaPluginGrant, CaptchaTask, ProxyResource
+
+__all__ = [
+    "BrowserResource",
+    "CaptchaTask",
+    "CaptchaPluginGrant",
+    "ProxyResource",
+    "ResourceProxy",
+    "ResourceProxyError",
+    "ResourceTransport",
+]

dataapp_resource_proxy/__main__.py

@@ -0,0 +1,65 @@
+"""Command-line helpers for local DataApp resource configuration."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import os
+import warnings
+from collections.abc import Sequence
+
+from ._local_config import (
+    load_project_config,
+    resolve_config_environment,
+    save_local_config,
+)
+from .errors import ResourceProxyError
+
+
+def _configure() -> int:
+    try:
+        project = load_project_config(os.environ)
+        environment = resolve_config_environment(os.environ, project)
+    except ResourceProxyError as error:
+        print(f"配置错误：{error}")
+        return 2
+    if environment is None:
+        print(
+            "未找到当前项目的 .dataapp-sdk.json。请在下载的 SDK 项目根目录运行，"
+            "或为独立项目显式设置 DATAAPP_ENVIRONMENT。"
+        )
+        return 2
+    print("平台托管 IP 代理和验证码服务会按实际用量产生资源费用。")
+    if project is not None:
+        print(f"请从当前平台账户中心获取 API Key：{project.api_keys_url}")
+    answer = input("确认在本地调试中使用这些收费资源？[y/N] ").strip().lower()
+    if answer not in {"y", "yes"}:
+        print("未保存配置，也不会发起任何托管资源请求。")
+        return 1
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", getpass.GetPassWarning)
+            api_key = getpass.getpass("请粘贴账户中心的 API Key（输入不会显示）：").strip()
+    except (EOFError, KeyboardInterrupt, getpass.GetPassWarning):
+        print("当前终端无法安全隐藏输入；未保存配置。请在交互式终端重新运行。")
+        return 2
+    if not api_key:
+        print("API Key 不能为空；未保存配置。")
+        return 2
+    path = save_local_config(api_key, environment=environment)
+    print(f"配置已安全保存到 {path}，文件权限已设置为 600。")
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="python -m dataapp_resource_proxy")
+    commands = parser.add_subparsers(dest="command", required=True)
+    commands.add_parser("configure", help="configure local managed resources securely")
+    options = parser.parse_args(argv)
+    if options.command == "configure":
+        return _configure()
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dataapp_resource_proxy/_local_config.py

@@ -0,0 +1,286 @@
+"""Project-bound defaults and private local managed-resource credentials."""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+import tempfile
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit
+
+from .errors import ResourceProxyError
+
+_CONFIG_ENV = "DATAAPP_LOCAL_CONFIG"
+_CONFIG_FILENAME = "local-resources.json"
+_PROJECT_CONFIG_FILENAME = ".dataapp-sdk.json"
+_PROJECT_CONFIG_MAX_BYTES = 64 * 1024
+_LEGACY_CONFIG_KEYS = frozenset({"schema_version", "DATAAPP_API_KEY"})
+_SCOPED_CONFIG_KEYS = frozenset({"schema_version", "environment", "DATAAPP_API_KEY"})
+_PROJECT_CONFIG_KEYS = frozenset(
+    {"schema_version", "environment", "api_keys_url", "resource_proxy"}
+)
+_RESOURCE_PROXY_KEYS = frozenset({"domestic_url", "overseas_url"})
+_ENVIRONMENTS = frozenset({"bazhuayu_pre", "bazhuayu", "octoparse_pre", "octoparse"})
+_PROFILE_ENVIRONMENTS = {
+    "bazhuayu_pre": "bazhuayu_pre",
+    "bazhuayu_overseas_pre": "bazhuayu_pre",
+    "bazhuayu": "bazhuayu",
+    "bazhuayu_overseas": "bazhuayu",
+    "octoparse_pre": "octoparse_pre",
+    "octoparse": "octoparse",
+}
+_PLATFORM_HOST_SUFFIXES = (".bazhuayu.com", ".octoparse.com")
+_PORTAL_HOST_SUFFIXES = {
+    "bazhuayu": ".bazhuayu.com",
+    "octoparse": ".octoparse.com",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ProjectSdkConfig:
+    """Non-secret defaults shipped with one downloaded project."""
+
+    environment: str
+    api_keys_url: str
+    domestic_url: str
+    overseas_url: str
+
+
+def load_project_config(
+    environ: Mapping[str, str] | None = None,
+    *,
+    directory: Path | None = None,
+) -> ProjectSdkConfig | None:
+    """Load strict project defaults from the current project root, if present."""
+    del environ  # Reserved for a future explicit, platform-controlled path.
+    path = (Path.cwd() if directory is None else directory) / _PROJECT_CONFIG_FILENAME
+    try:
+        info = path.lstat()
+    except FileNotFoundError:
+        return None
+    except OSError as error:
+        raise _configuration_error(
+            f"cannot inspect {_PROJECT_CONFIG_FILENAME} ({type(error).__name__})"
+        ) from None
+    if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode):
+        raise _configuration_error(f"{_PROJECT_CONFIG_FILENAME} must be a regular file")
+    if info.st_size > _PROJECT_CONFIG_MAX_BYTES:
+        raise _configuration_error(f"{_PROJECT_CONFIG_FILENAME} is too large")
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, ValueError) as error:
+        raise _configuration_error(
+            f"cannot load {_PROJECT_CONFIG_FILENAME} ({type(error).__name__})"
+        ) from None
+    if (
+        not isinstance(payload, dict)
+        or set(payload) != _PROJECT_CONFIG_KEYS
+        or payload.get("schema_version") != 1
+        or payload.get("environment") not in _ENVIRONMENTS
+        or not isinstance(payload.get("api_keys_url"), str)
+        or not isinstance(payload.get("resource_proxy"), dict)
+        or set(payload["resource_proxy"]) != _RESOURCE_PROXY_KEYS
+        or not isinstance(payload["resource_proxy"].get("domestic_url"), str)
+        or not isinstance(payload["resource_proxy"].get("overseas_url"), str)
+    ):
+        raise _configuration_error(f"{_PROJECT_CONFIG_FILENAME} has an unsupported format")
+    environment = payload["environment"]
+    api_keys_url = _validated_platform_url(
+        payload["api_keys_url"], environment=environment, api_keys=True
+    )
+    domestic_url = _validated_platform_url(
+        payload["resource_proxy"]["domestic_url"], environment=environment
+    )
+    overseas_url = _validated_platform_url(
+        payload["resource_proxy"]["overseas_url"], environment=environment
+    )
+    return ProjectSdkConfig(
+        environment=environment,
+        api_keys_url=api_keys_url,
+        domestic_url=domestic_url,
+        overseas_url=overseas_url,
+    )
+
+
+def resolve_config_environment(
+    environ: Mapping[str, str], project: ProjectSdkConfig | None
+) -> str | None:
+    """Resolve and validate the canonical account environment for local config."""
+    current = environ.get("DATAAPP_ENVIRONMENT") or None
+    legacy = environ.get("DATAOS_ENVIRONMENT") or None
+    if current and legacy and current != legacy:
+        raise _configuration_error(
+            "DATAAPP_ENVIRONMENT conflicts with deprecated DATAOS_ENVIRONMENT"
+        )
+    profile = current or legacy
+    if profile is not None and profile not in _PROFILE_ENVIRONMENTS:
+        raise _configuration_error("DATAAPP_ENVIRONMENT is not supported")
+    explicit = _PROFILE_ENVIRONMENTS.get(profile) if profile is not None else None
+    if project is not None and explicit is not None and explicit != project.environment:
+        raise _configuration_error(
+            "DATAAPP_ENVIRONMENT conflicts with the downloaded project environment"
+        )
+    return project.environment if project is not None else explicit
+
+
+def local_config_path(
+    environ: Mapping[str, str] | None = None, *, environment: str | None = None
+) -> Path:
+    """Return the private config path without creating it."""
+    env = os.environ if environ is None else environ
+    explicit = env.get(_CONFIG_ENV)
+    if explicit:
+        return Path(explicit).expanduser()
+    config_root = env.get("XDG_CONFIG_HOME")
+    root = Path(config_root).expanduser() if config_root else Path.home() / ".config"
+    parent = root / "bazhuayu-dataapp"
+    return (
+        parent / environment / _CONFIG_FILENAME
+        if environment is not None
+        else parent / _CONFIG_FILENAME
+    )
+
+
+def load_local_config(
+    environ: Mapping[str, str], *, environment: str | None = None
+) -> dict[str, str]:
+    """Load one environment-bound value-only config with private permissions."""
+    path = local_config_path(environ, environment=environment)
+    try:
+        info = path.lstat()
+    except FileNotFoundError:
+        return {}
+    except OSError as error:
+        raise _configuration_error(
+            f"cannot read local managed-resource configuration ({type(error).__name__})"
+        ) from None
+    if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode):
+        raise _configuration_error("local managed-resource configuration must be a regular file")
+    if stat.S_IMODE(info.st_mode) & 0o077:
+        raise _configuration_error(
+            "local managed-resource configuration is not private; run "
+            "`python -m dataapp_resource_proxy configure` to repair it"
+        )
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, ValueError) as error:
+        raise _configuration_error(
+            f"cannot load local managed-resource configuration ({type(error).__name__})"
+        ) from None
+    if environment is None:
+        valid = (
+            isinstance(payload, dict)
+            and set(payload) == _LEGACY_CONFIG_KEYS
+            and payload.get("schema_version") == 1
+        )
+    else:
+        valid = (
+            isinstance(payload, dict)
+            and set(payload) == _SCOPED_CONFIG_KEYS
+            and payload.get("schema_version") == 2
+            and payload.get("environment") == environment
+        )
+    if (
+        not valid
+        or not isinstance(payload.get("DATAAPP_API_KEY"), str)
+        or not payload["DATAAPP_API_KEY"].strip()
+    ):
+        raise _configuration_error(
+            "local managed-resource configuration does not match the current environment; "
+            "run `python -m dataapp_resource_proxy configure` to replace it"
+        )
+    return {"DATAAPP_API_KEY": payload["DATAAPP_API_KEY"]}
+
+
+def save_local_config(
+    api_key: str,
+    environ: Mapping[str, str] | None = None,
+    *,
+    environment: str | None = None,
+) -> Path:
+    """Atomically store the local API key in a mode-600 environment-bound file."""
+    if not isinstance(api_key, str) or not api_key.strip():
+        raise ValueError("API Key must not be empty")
+    env = os.environ if environ is None else environ
+    path = local_config_path(env, environment=environment)
+    parent_existed = path.parent.exists()
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    if not env.get(_CONFIG_ENV) and parent_existed:
+        os.chmod(path.parent, 0o700)
+    payload: dict[str, Any]
+    if environment is None:
+        payload = {"schema_version": 1, "DATAAPP_API_KEY": api_key.strip()}
+    else:
+        payload = {
+            "schema_version": 2,
+            "environment": environment,
+            "DATAAPP_API_KEY": api_key.strip(),
+        }
+    descriptor, temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent, text=True)
+    try:
+        os.fchmod(descriptor, 0o600)
+        with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
+            descriptor = -1
+            json.dump(payload, stream, ensure_ascii=False)
+            stream.write("\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+        os.chmod(path, 0o600)
+    finally:
+        if descriptor >= 0:
+            os.close(descriptor)
+        try:
+            os.unlink(temporary)
+        except FileNotFoundError:
+            pass
+    return path
+
+
+def _validated_platform_url(value: str, *, environment: str, api_keys: bool = False) -> str:
+    raw = value.strip()
+    parsed = urlsplit(raw)
+    hostname = (parsed.hostname or "").lower()
+    try:
+        port = parsed.port
+    except ValueError:
+        port = -1
+    if (
+        parsed.scheme != "https"
+        or not hostname
+        or port not in {None, 443}
+        or parsed.username is not None
+        or parsed.password is not None
+        or parsed.query
+        or parsed.fragment
+        or not any(hostname.endswith(suffix) for suffix in _PLATFORM_HOST_SUFFIXES)
+    ):
+        raise _configuration_error(f"{_PROJECT_CONFIG_FILENAME} contains an unsafe platform URL")
+    labels = hostname.split(".")
+    is_pre_host = any(label == "pre" or label.startswith("pre-") for label in labels)
+    if environment.endswith("_pre") != is_pre_host:
+        raise _configuration_error(f"{_PROJECT_CONFIG_FILENAME} mixes pre and production endpoints")
+    if api_keys:
+        brand = environment.removesuffix("_pre")
+        portal_suffix = _PORTAL_HOST_SUFFIXES[brand]
+        if hostname != portal_suffix.removeprefix(".") and not hostname.endswith(portal_suffix):
+            raise _configuration_error(
+                f"{_PROJECT_CONFIG_FILENAME} API Keys URL does not match its environment"
+            )
+        if parsed.path.rstrip("/") != "/console/account-center/api-keys":
+            raise _configuration_error(
+                f"{_PROJECT_CONFIG_FILENAME} contains an invalid API Keys URL"
+            )
+    elif parsed.path not in {"", "/"}:
+        raise _configuration_error(
+            f"{_PROJECT_CONFIG_FILENAME} contains an invalid Resource Proxy URL"
+        )
+    return raw.rstrip("/")
+
+
+def _configuration_error(message: str) -> ResourceProxyError:
+    return ResourceProxyError(message, code="configuration-error")