yicloud-sdk-python 0.1.0__py3-none-any.whl

yicloud/base/msgs/__init__.py

@@ -0,0 +1,226 @@
+import contextvars
+from typing import Any, Dict, Generic, Optional, Tuple, TypeVar, Union, get_args, get_origin
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, fields, is_dataclass
+
+
+# === Response Types ===
+
+class Response(ABC):
+    """Response interface matching Go SDK's Response."""
+
+    @abstractmethod
+    def get_code(self) -> int: ...
+
+    @abstractmethod
+    def get_msg(self) -> str: ...
+
+    @abstractmethod
+    def get_data(self) -> Any: ...
+
+    @abstractmethod
+    def get_cost(self) -> int: ...
+
+    @abstractmethod
+    def get_err(self) -> str: ...
+
+    @abstractmethod
+    def fill_from_json(self, data: bytes): ...
+
+
+@dataclass
+class Header:
+    """Header struct matching Go SDK's Header."""
+    code: int
+    msg: str
+    cost: int = 0
+    err: str = ""
+
+    def get_code(self) -> int:
+        return self.code
+
+    def get_msg(self) -> str:
+        return self.msg
+
+    def get_cost(self) -> int:
+        return self.cost
+
+    def get_err(self) -> str:
+        return self.err
+
+    def __str__(self) -> str:
+        return f"code:{self.code}, msg:{self.msg}, cost:{self.cost}, error:{self.err}"
+
+
+T = TypeVar("T")
+
+
+def _dict_to_dataclass(target_type, data):
+    """Recursively convert a dict to a typed dataclass instance."""
+    if not is_dataclass(target_type) or not isinstance(data, dict):
+        return data
+
+    field_types = {f.name: f.type for f in fields(target_type)}
+
+    kwargs = {}
+    for key, value in data.items():
+        if key in field_types:
+            kwargs[key] = _convert_value(field_types[key], value)
+
+    return target_type(**kwargs)
+
+
+def _convert_value(field_type, value):
+    """Convert a value to match the target type annotation."""
+    if value is None:
+        return None
+
+    origin = get_origin(field_type)
+    args = get_args(field_type)
+
+    # Handle Optional[X] = Union[X, None]
+    if origin is Union:
+        non_none = [a for a in args if a is not type(None)]
+        if len(non_none) == 1:
+            return _convert_value(non_none[0], value)
+        return value
+
+    # Handle List[X]
+    if origin is list:
+        if args and is_dataclass(args[0]):
+            return [_dict_to_dataclass(args[0], item) if isinstance(item, dict) else item for item in value]
+        return value
+
+    # Handle Dict[str, X]
+    if origin is dict:
+        if args and len(args) == 2 and is_dataclass(args[1]):
+            return {k: _dict_to_dataclass(args[1], v) if isinstance(v, dict) else v for k, v in value.items()}
+        return value
+
+    # Handle direct dataclass field
+    if is_dataclass(field_type) and isinstance(value, dict):
+        return _dict_to_dataclass(field_type, value)
+
+    return value
+
+
+@dataclass
+class Rsp(Generic[T], Response):
+    """Generic response type matching Go SDK's Rsp[T]."""
+    header: Header
+    data: Optional[T] = None
+
+    def __init__(self, header: Optional[Header] = None, data: Optional[T] = None):
+        if header is None:
+            header = Header(code=0, msg="")
+        self.header = header
+        self.data = data
+
+    @classmethod
+    def empty(cls) -> "Rsp[None]":
+        return Rsp(header=Header(code=0, msg=""), data=None)
+
+    def get_code(self) -> int:
+        return self.header.code
+
+    def get_msg(self) -> str:
+        return self.header.msg
+
+    def get_data(self) -> Any:
+        return self.data
+
+    def get_cost(self) -> int:
+        return self.header.cost
+
+    def get_err(self) -> str:
+        return self.header.err
+
+    def fill_from_json(self, data: bytes):
+        """Fill data from JSON bytes."""
+        pass  # Implementation optional
+
+    def get_typed_data(self) -> Optional[T]:
+        if self.data is None:
+            return None
+        if not isinstance(self.data, dict):
+            return self.data
+
+        orig = getattr(self, "__orig_class__", None)
+        if orig is not None:
+            type_args = getattr(orig, "__args__", None)
+            if type_args and type_args[0] is not None and type_args[0] is not type(None):
+                target = type_args[0]
+                if is_dataclass(target):
+                    return _dict_to_dataclass(target, self.data)
+
+        return self.data
+
+
+# Type aliases matching Go SDK
+RawRsp = Rsp[Any]
+Empty = Rsp[None]
+
+
+# === Context Metadata ===
+
+# Context var for storing response metadata
+_ctx_meta = contextvars.ContextVar[Optional["RspMeta"]]("rsp_meta", default=None)
+
+
+@dataclass
+class RspMeta:
+    """Response metadata matching Go SDK's RspMeta."""
+    request_id: str = ""
+    cost: int = 0
+    err: str = ""
+
+
+# Type alias for context (None represents no context)
+Context = Optional[Dict[str, Any]]
+
+
+def with_meta_ctx(ctx: Context = None) -> Tuple[Context, RspMeta]:
+    """Create a new context with response metadata."""
+    meta = RspMeta()
+    # Store meta reference in context dict
+    if ctx is None:
+        ctx = {}
+    ctx["_meta"] = meta
+    return ctx, meta
+
+
+def new_meta_ctx() -> Tuple[Context, RspMeta]:
+    """Create a new meta context with empty base context."""
+    return with_meta_ctx(None)
+
+
+def get_rsp_meta(ctx: Context) -> Tuple[Optional[RspMeta], bool]:
+    """Get response metadata from context."""
+    if ctx is None:
+        return None, False
+
+    meta = ctx.get("_meta")
+    if meta is not None:
+        return meta, True
+    return None, False
+
+
+def clear_meta_ctx(ctx: Context = None):
+    """Clear the meta context."""
+    if ctx is not None:
+        ctx.pop("_meta", None)
+
+
+__all__ = [
+    "Response",
+    "Header",
+    "Rsp",
+    "RawRsp",
+    "Empty",
+    "RspMeta",
+    "with_meta_ctx",
+    "new_meta_ctx",
+    "get_rsp_meta",
+    "clear_meta_ctx",
+    "Context",
+]

yicloud/base/utils/__init__.py

@@ -0,0 +1,6 @@
+from yicloud.base.utils.helps import get_current_func_name, build_query
+
+__all__ = [
+    "get_current_func_name",
+    "build_query",
+]

yicloud/base/utils/helps.py

@@ -0,0 +1,110 @@
+import inspect
+import dataclasses
+from typing import Any, Optional, Type, get_type_hints
+from collections import OrderedDict
+from urllib.parse import urlencode
+
+
+def get_current_func_name() -> str:
+    """Get current function name for path construction."""
+    try:
+        frame = inspect.stack()[1]
+        return frame.function
+    except (IndexError, ValueError):
+        return "unknown"
+
+
+def parse_json_tag(field_name: str, field_type: Type, default_value: Any = None):
+    """
+    Parse json tag from field (simulating Go's json tag behavior).
+
+    Since Python doesn't have struct tags, we use a convention:
+    - Field name in snake_case maps to PascalCase for json key
+    - We'll use a helper class attribute or __json__ dict for customization
+
+    For simplicity, we'll convert snake_case to CamelCase like Go.
+    """
+    # Default key: convert to PascalCase from snake_case
+    if "_" in field_name:
+        parts = field_name.split("_")
+        key = "".join(p.capitalize() for p in parts)
+    else:
+        key = field_name[0].upper() + field_name[1:] if field_name else field_name
+
+    # For now, we don't have a way to specify omitempty or skip in Python
+    # without using custom decorators or separate metadata
+    omitempty = False
+    skip = False
+
+    # Check if field value is Optional (has None as default)
+    if default_value is None:
+        # For Optional fields, we treat them as pointer-like in Go
+        pass
+
+    return key, omitempty, skip
+
+
+def build_query(kvs: Any) -> str:
+    """
+    Build query string from dataclass/dict using field annotations.
+    Matches Go SDK's BuildQuery behavior.
+
+    For dataclasses, uses the field name (converted to CamelCase) as key.
+    For None values in Optional fields, skips them.
+    For zero values in non-Optional fields without omitempty, includes them.
+
+    Supported types: str, int, float, bool
+    """
+    if kvs is None:
+        return ""
+
+    if isinstance(kvs, str):
+        return kvs
+
+    values = OrderedDict()
+
+    # Handle dataclass
+    if dataclasses.is_dataclass(kvs):
+        for field in dataclasses.fields(kvs):
+            field_name = field.name
+            field_value = getattr(kvs, field_name)
+
+            # Parse the json tag (key name)
+            # In Python, we convert snake_case to CamelCase
+            key, omitempty, skip = parse_json_tag(field_name, field.type)
+
+            if skip:
+                continue
+
+            # Handle Optional/None fields (like Go pointers)
+            if field_value is None:
+                # Check if field has a default of None (Optional)
+                # If so, skip (like nil pointer in Go)
+                if field.default is dataclasses.MISSING and field.default_factory is dataclasses.MISSING:
+                    # No default, None means explicit skip? Actually in Go, nil = always skip
+                    continue
+                else:
+                    # Has default of None, skip if None
+                    continue
+
+            # Handle omitempty for non-None values
+            if omitempty and field_value in ("", 0, False, [], {}):
+                continue
+
+            # Convert value to string
+            if isinstance(field_value, bool):
+                values[key] = "true" if field_value else "false"
+            else:
+                values[key] = str(field_value)
+
+    # Handle dict
+    elif isinstance(kvs, dict):
+        for key, value in kvs.items():
+            if value is None:
+                continue
+            if isinstance(value, bool):
+                values[key] = "true" if value else "false"
+            else:
+                values[key] = str(value)
+
+    return urlencode(values)

yicloud/base/utils/retry/__init__.py

@@ -0,0 +1,27 @@
+from yicloud.base.utils.retry.retry import (
+    retry,
+    is_retry_err,
+    retryErr,
+    with_attempts,
+    with_logs,
+    with_retry_if,
+    with_on_retry,
+    with_duration,
+    with_factor,
+    with_jitter,
+    Context,
+)
+
+__all__ = [
+    "retry",
+    "is_retry_err",
+    "retryErr",
+    "with_attempts",
+    "with_logs",
+    "with_retry_if",
+    "with_on_retry",
+    "with_duration",
+    "with_factor",
+    "with_jitter",
+    "Context",
+]

yicloud/base/utils/retry/retry.py

@@ -0,0 +1,162 @@
+import time
+import random
+import math
+from typing import Callable, Optional, Any, Dict, Tuple
+
+
+class retryErr(Exception):
+    """Retry error wrapping the original error."""
+
+    def __init__(self, desc: str, origin: Optional[Exception] = None):
+        self.desc = desc
+        self.origin = origin
+
+    def __str__(self) -> str:
+        if self.origin:
+            return f"{self.desc}: {self.origin}"
+        return self.desc
+
+    def __cause__(self) -> Optional[Exception]:
+        return self.origin
+
+
+def is_retry_err(err: Exception) -> Tuple[Optional[Exception], bool]:
+    """Check if error is a retry error."""
+    if isinstance(err, retryErr):
+        return err.origin, True
+    return None, False
+
+
+class retryOptions:
+    """Retry options."""
+
+    def __init__(self):
+        self.attempts = 3
+        self.duration = 1.0  # seconds
+        self.factor = 2.0
+        self.jitter = 0.1
+        self.enable_log = False
+        self.retry_if: Optional[Callable[[Exception], bool]] = None
+        self.on_retry: Optional[Callable[[int, Exception, float], None]] = None
+
+
+def default_options() -> retryOptions:
+    return retryOptions()
+
+
+def with_attempts(n: int) -> Callable[[retryOptions], None]:
+    return lambda o: setattr(o, 'attempts', n)
+
+
+def with_logs(enable: bool) -> Callable[[retryOptions], None]:
+    return lambda o: setattr(o, 'enable_log', enable)
+
+
+def with_retry_if(fn: Callable[[Exception], bool]) -> Callable[[retryOptions], None]:
+    return lambda o: setattr(o, 'retry_if', fn)
+
+
+def with_on_retry(fn: Callable[[int, Exception, float], None]) -> Callable[[retryOptions], None]:
+    return lambda o: setattr(o, 'on_retry', fn)
+
+
+def with_duration(d: float) -> Callable[[retryOptions], None]:
+    return lambda o: setattr(o, 'duration', d)
+
+
+def with_factor(f: float) -> Callable[[retryOptions], None]:
+    return lambda o: setattr(o, 'factor', f)
+
+
+def with_jitter(j: float) -> Callable[[retryOptions], None]:
+    return lambda o: setattr(o, 'jitter', j)
+
+
+def jitter(duration: float, max_factor: float) -> float:
+    """Add random jitter to duration."""
+    if max_factor <= 0:
+        return duration
+    return duration * (1 + random.random() * max_factor)
+
+
+def next_sleep(o: retryOptions, step: int) -> float:
+    """Calculate next sleep duration."""
+    d = float(o.duration)
+
+    if o.factor != 0:
+        d = d * math.pow(o.factor, float(step))
+
+    if o.jitter > 0:
+        d = jitter(d, float(o.jitter))
+
+    return d
+
+
+Context = Optional[Dict[str, Any]]
+
+
+def retry(
+    ctx: Context,
+    fn: Callable[[Context], Any],
+    *opts: Callable[[retryOptions], None]
+) -> Any:
+    """
+    Retry function with exponential backoff and jitter.
+
+    Args:
+        ctx: Optional context dict (can be None)
+        fn: Function to execute, takes context as argument
+        *opts: Retry options
+
+    Returns:
+        Result of fn if successful
+
+    Raises:
+        retryErr if all attempts fail
+    """
+    cfg = default_options()
+    for opt in opts:
+        opt(cfg)
+
+    err: Optional[Exception] = None
+    for i in range(cfg.attempts):
+        # Execute the function
+        try:
+            result = fn(ctx)
+            return result
+        except Exception as e:
+            err = e
+
+            # Check if should retry based on retry_if
+            if cfg.retry_if is not None and not cfg.retry_if(e):
+                raise e
+
+            # Last attempt, break
+            if i == cfg.attempts - 1:
+                break
+
+            # Calculate sleep time
+            sleep = next_sleep(cfg, i)
+
+            # Call on_retry callback
+            if cfg.on_retry is not None:
+                cfg.on_retry(i + 1, e, sleep)
+
+            # Log if enabled
+            if cfg.enable_log:
+                from ... import log
+                log.warnf(
+                    "retry %d/%d after %s, err: %s",
+                    i + 1,
+                    cfg.attempts,
+                    sleep,
+                    str(e),
+                )
+
+            # Sleep
+            time.sleep(sleep)
+
+    raise retryErr(
+        f"after {cfg.attempts} attempts, last error: {err}",
+        err if err else None
+    )

yicloud/services/__init__.py

@@ -0,0 +1,24 @@
+# Services package
+# All service modules matching Go SDK structure
+
+from . import iam
+from . import job
+from . import bc
+from . import mc
+from . import oss
+from . import registry
+from . import modelset
+from . import modelrepo
+from . import fs
+
+__all__ = [
+    "iam",
+    "job",
+    "bc",
+    "mc",
+    "oss",
+    "registry",
+    "modelset",
+    "modelrepo",
+    "fs",
+]

yicloud/services/bc/__init__.py

@@ -0,0 +1,9 @@
+from yicloud.services.bc.client import BCClient as Client, client, use_client
+from . import actions, models
+
+from .actions import list_billing_details
+from .models import (
+    ListBillingDetailsReq,
+    ListBillingDetailsRes,
+    InstanceUsageView,
+)

yicloud/services/bc/actions.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from yicloud.base import msgs
+from yicloud.services.bc import models
+from yicloud.services.bc.client import client
+
+_PRODUCT_CODE = "bc"
+_LAST_VERSION = "v1alpha1"
+
+
+def list_billing_details(ctx: Optional[dict], req: models.ListBillingDetailsReq) -> models.ListBillingDetailsRes:
+    """
+    GET /bc/v1alpha1/ListBillingDetails
+    Action: ListBillingDetails
+
+    Returns ListBillingDetailsRes on success.
+
+    Raises YiCloudException on error.
+    """
+    path = f"/{_PRODUCT_CODE}/{_LAST_VERSION}/ListBillingDetails"
+    rsp = msgs.Rsp[models.ListBillingDetailsRes]()
+    client.base.get(ctx, path, req, rsp)
+    return rsp.get_typed_data()

yicloud/services/bc/client.py

@@ -0,0 +1,19 @@
+from yicloud.base import Client
+
+
+class BCClient:
+    """BC (Billing Center) service client, matching Go SDK's services/bc/client.go."""
+
+    def __init__(self, base_client: Client = None):
+        self.base = base_client
+        self.product_code = "bc"
+        self.last_version = "v1alpha1"
+
+
+# Singleton matching Go SDK
+client: BCClient = BCClient()
+
+
+def use_client(cli: Client) -> None:
+    """Set the base client for BC service."""
+    client.base = cli

yicloud/services/bc/models.py

@@ -0,0 +1,61 @@
+# Code generated from Go SDK's services/bc/models.go. DO NOT EDIT.
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ListBillingDetailsReq:
+    """List billing details request."""
+    Tenant: str = ""
+    Project: str = ""
+    StartTime: str = ""
+    EndTime: str = ""
+    BillingCycle: str = ""
+    ProductName: str = ""
+    BillingMode: str = ""
+    InstanceId: str = ""
+    InstanceName: str = ""
+    ResourceCreator: str = ""
+    RelatedResourceId: str = ""
+    RelatedResourceName: str = ""
+    RelatedResourceType: str = ""
+    SortBy: str = ""
+    SortOrder: str = ""
+    Limit: int = 0
+    Offset: int = 0
+
+
+@dataclass
+class InstanceUsageView:
+    """Instance usage view."""
+    Tenant: str = ""
+    BillingCycle: str = ""
+    BillingTime: str = ""
+    ProductName: str = ""
+    BillingMode: str = ""
+    MetricCode: str = ""
+    MetricUnit: str = ""
+    UsageDurationHours: float = 0.0
+    UsageAmount: float = 0.0
+    InstanceCount: int = 0
+    UsageTimeRangeStart: str = ""
+    UsageTimeRangeEnd: str = ""
+    InstanceId: str = ""
+    InstanceName: str = ""
+    InstanceIdName: str = ""
+    RayJobName: str = ""
+    RayGroupName: str = ""
+    SpecDesc: str = ""
+    RelatedResourceName: str = ""
+    Project: str = ""
+    ResourceCreator: str = ""
+
+
+@dataclass
+class ListBillingDetailsRes:
+    """List billing details response."""
+    Items: list[InstanceUsageView] = field(default_factory=list)
+    Total: int = 0
+    Limit: int = 0
+    Offset: int = 0

yicloud/services/fs/__init__.py

@@ -0,0 +1,29 @@
+from yicloud.services.fs.client import FSClient as Client, client, use_client
+from . import actions, models
+
+from .actions import (
+    list_dir,
+    get_file_info,
+    create_fileset_with_quota,
+    delete_fileset,
+    list_filesets_with_quota_info,
+    set_fileset_quota,
+    get_fileset,
+)
+from .models import (
+    FileInfo,
+    FilesetInfo,
+    PaginatedFileInfo,
+    FilesetWithQuotaInfo,
+    GetFSBucketResponse,
+    BucketResponse,
+    PaginatedFileSetWithQuotaInfo,
+    ListDirRequest,
+    GetFileInfoRequest,
+    Authorization,
+    CreateFilesetWithQuotaRequest,
+    DeleteFilesetRequest,
+    SetFilesetQuotaRequest,
+    GetFilesetRequest,
+    ListFilesetsWithQuotaInfoRequest,
+)