CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-tencentcloud-sdk-python

Comprehensive Python SDK for integrating with Tencent Cloud services, supporting 240+ cloud services with authentication, error handling, and retry mechanisms.

Overview
Eval results
Files

data-models.mddocs/

Data Models

Base model class and service-specific request/response models providing JSON serialization, data validation, and structured data handling for all API interactions. All models inherit from AbstractModel and support automatic serialization.

Capabilities

Abstract Model Base Class

Foundation class providing JSON serialization, deserialization, and data validation capabilities for all request and response objects in the SDK.

class AbstractModel:
    def __init__(self):
        """
        Initialize base model with empty attributes.
        All model properties are set to None by default.
        """
    
    def to_json_string(self, indent: int = None) -> str:
        """
        Serialize model to JSON string.
        
        Parameters:
        - indent (int, optional): JSON indentation for pretty printing
        
        Returns:
        str: JSON string representation of the model
        """
    
    def from_json_string(self, json_string: str):
        """
        Deserialize JSON string to populate model attributes.
        
        Parameters:
        - json_string (str): JSON string to deserialize
        
        Returns:
        AbstractModel: Self for method chaining
        """
    
    def _serialize(self) -> dict:
        """
        Internal method to convert model to dictionary.
        
        Returns:
        dict: Dictionary representation excluding None values
        """

Basic Model Usage:

from tencentcloud.cvm.v20170312 import models

# Create request model
request = models.DescribeInstancesRequest()
request.InstanceIds = ["ins-12345678", "ins-87654321"]
request.Limit = 20
request.Offset = 0

# Serialize to JSON
json_str = request.to_json_string(indent=2)
print(json_str)

# Deserialize from JSON
new_request = models.DescribeInstancesRequest()
new_request.from_json_string(json_str)

Request Models

Structured input objects for API calls, providing type safety and parameter validation. All request models follow the naming pattern {Action}Request.

Common Request Patterns

Pagination Support:

# Common pagination parameters across many request models
class PaginatedRequest(AbstractModel):
    def __init__(self):
        self.Limit: int = None      # Maximum items to return (usually 20-100)
        self.Offset: int = None     # Starting position for pagination

Filtering Support:

class Filter(AbstractModel):
    def __init__(self):
        """
        Filter criteria for query operations.
        """
        self.Name: str = None       # Filter field name
        self.Values: list = None    # List of filter values

# Used in many describe requests
class FilteredRequest(AbstractModel):
    def __init__(self):
        self.Filters: list = None   # List of Filter objects

Placement Information:

class Placement(AbstractModel):
    def __init__(self):
        """
        Resource placement configuration.
        """
        self.Zone: str = None           # Availability zone
        self.ProjectId: int = None      # Project ID
        self.HostIds: list = None       # Dedicated host IDs

CVM Request Models

class RunInstancesRequest(AbstractModel):
    def __init__(self):
        """Request to create and launch CVM instances."""
        self.ImageId: str = None                        # System image ID
        self.InstanceType: str = None                   # Instance specification
        self.Placement: Placement = None                # Placement configuration
        self.InstanceCount: int = None                  # Number of instances
        self.InstanceName: str = None                   # Instance name
        self.LoginSettings: LoginSettings = None       # Login configuration
        self.SecurityGroupIds: list = None             # Security group IDs
        self.VirtualPrivateCloud: VirtualPrivateCloud = None  # VPC configuration
        self.SystemDisk: SystemDisk = None             # System disk configuration
        self.DataDisks: list = None                    # Data disk configurations
        self.InternetAccessible: InternetAccessible = None    # Internet access
        self.InstanceChargeType: str = None            # Billing method
        self.TagSpecification: list = None             # Resource tags

class DescribeInstancesRequest(AbstractModel):
    def __init__(self):
        """Request to query CVM instance information."""
        self.InstanceIds: list = None      # Specific instance IDs
        self.Filters: list = None          # Filter criteria
        self.Offset: int = None            # Pagination offset
        self.Limit: int = None             # Maximum results

class TerminateInstancesRequest(AbstractModel):
    def __init__(self):
        """Request to terminate CVM instances."""
        self.InstanceIds: list = None      # Instance IDs to terminate

CBS Request Models

class CreateDisksRequest(AbstractModel):
    def __init__(self):
        """Request to create cloud block storage disks."""
        self.DiskType: str = None          # Disk type (CLOUD_BASIC, CLOUD_PREMIUM, CLOUD_SSD)
        self.DiskSize: int = None          # Disk size in GB
        self.Placement: Placement = None   # Placement configuration
        self.DiskName: str = None          # Disk name
        self.DiskCount: int = None         # Number of disks
        self.DiskChargeType: str = None    # Billing method
        self.Shareable: bool = None        # Multi-instance attachment support

class AttachDisksRequest(AbstractModel):
    def __init__(self):
        """Request to attach disks to instances."""
        self.DiskIds: list = None          # Disk IDs to attach
        self.InstanceId: str = None        # Target instance ID
        self.DeleteWithInstance: bool = None  # Delete disk when instance terminates

Response Models

Structured output objects from API calls containing results, metadata, and error information. All response models follow the naming pattern {Action}Response.

Common Response Structure

class CommonResponse(AbstractModel):
    def __init__(self):
        """Common response structure across all APIs."""
        self.RequestId: str = None     # Unique request identifier
        self.Error: Error = None       # Error information if call failed

class Error(AbstractModel):
    def __init__(self):
        """Error information structure."""
        self.Code: str = None          # Error code
        self.Message: str = None       # Error message

CVM Response Models

class RunInstancesResponse(AbstractModel):
    def __init__(self):
        """Response from instance creation."""
        self.InstanceIdSet: list = None    # Created instance IDs
        self.RequestId: str = None         # Request identifier

class DescribeInstancesResponse(AbstractModel):
    def __init__(self):
        """Response from instance query."""
        self.TotalCount: int = None        # Total matching instances
        self.InstanceSet: list = None      # List of Instance objects
        self.RequestId: str = None         # Request identifier

class TerminateInstancesResponse(AbstractModel):
    def __init__(self):
        """Response from instance termination."""
        self.RequestId: str = None         # Request identifier

CBS Response Models

class CreateDisksResponse(AbstractModel):
    def __init__(self):
        """Response from disk creation."""
        self.DiskIdSet: list = None        # Created disk IDs  
        self.RequestId: str = None         # Request identifier

class DescribeDisksResponse(AbstractModel):
    def __init__(self):
        """Response from disk query."""
        self.TotalCount: int = None        # Total matching disks
        self.DiskSet: list = None          # List of Disk objects
        self.RequestId: str = None         # Request identifier

Data Models

Complex structured objects representing cloud resources, configurations, and metadata. These models are used within request and response objects.

Instance Models

class Instance(AbstractModel):
    def __init__(self):
        """CVM instance information."""
        self.InstanceId: str = None            # Instance identifier
        self.InstanceName: str = None          # Instance name
        self.InstanceType: str = None          # Instance specification
        self.InstanceState: str = None         # Current state
        self.ImageId: str = None               # System image ID
        self.Placement: Placement = None       # Placement information
        self.PrivateIpAddresses: list = None   # Private IP addresses
        self.PublicIpAddresses: list = None    # Public IP addresses
        self.SystemDisk: SystemDisk = None     # System disk information
        self.DataDisks: list = None            # Data disk information
        self.VirtualPrivateCloud: VirtualPrivateCloud = None  # VPC info
        self.SecurityGroupIds: list = None     # Security group IDs
        self.Tags: list = None                 # Resource tags
        self.CreatedTime: str = None           # Creation timestamp
        self.ExpiredTime: str = None           # Expiration timestamp

Storage Models

class Disk(AbstractModel):
    def __init__(self):
        """Cloud block storage disk information."""
        self.DiskId: str = None                # Disk identifier
        self.DiskName: str = None              # Disk name
        self.DiskType: str = None              # Disk type
        self.DiskSize: int = None              # Disk size in GB
        self.DiskState: str = None             # Current state
        self.Attached: bool = None             # Attachment status
        self.InstanceId: str = None            # Attached instance ID
        self.Placement: Placement = None       # Placement information
        self.CreatedTime: str = None           # Creation timestamp
        self.DiskChargeType: str = None        # Billing method

class SystemDisk(AbstractModel):
    def __init__(self):
        """System disk configuration."""
        self.DiskType: str = None              # Disk type
        self.DiskSize: int = None              # Disk size in GB
        self.DiskId: str = None                # Disk identifier

class DataDisk(AbstractModel):
    def __init__(self):
        """Data disk configuration."""
        self.DiskType: str = None              # Disk type
        self.DiskSize: int = None              # Disk size in GB
        self.DeleteWithInstance: bool = None   # Delete with instance
        self.SnapshotId: str = None            # Source snapshot ID

Network Models

class VirtualPrivateCloud(AbstractModel):
    def __init__(self):
        """VPC configuration."""
        self.VpcId: str = None                 # VPC identifier
        self.SubnetId: str = None              # Subnet identifier
        self.AsVpcGateway: bool = None         # VPC gateway role
        self.PrivateIpAddresses: list = None   # Private IP addresses

class InternetAccessible(AbstractModel):
    def __init__(self):
        """Internet access configuration."""
        self.InternetChargeType: str = None    # Billing method
        self.InternetMaxBandwidthOut: int = None  # Outbound bandwidth limit
        self.PublicIpAssigned: bool = None     # Assign public IP
        self.BandwidthPackageId: str = None    # Bandwidth package ID

Authentication Models

class LoginSettings(AbstractModel):
    def __init__(self):
        """Instance login configuration."""
        self.Password: str = None              # Login password
        self.KeyIds: list = None               # SSH key pair IDs
        self.KeepImageLogin: bool = None       # Keep image login settings

Advanced Model Usage

Complex Request Construction:

from tencentcloud.cvm.v20170312 import models

# Build complex instance launch request
request = models.RunInstancesRequest()

# Basic configuration
request.ImageId = "img-9qabwvbn"  # Ubuntu 20.04
request.InstanceType = "S5.LARGE8"  # 4 vCPU, 8GB RAM
request.InstanceCount = 2

# Placement configuration
placement = models.Placement()
placement.Zone = "ap-shanghai-1"
placement.ProjectId = 0
request.Placement = placement

# VPC configuration
vpc = models.VirtualPrivateCloud()
vpc.VpcId = "vpc-12345678"
vpc.SubnetId = "subnet-87654321"
vpc.PrivateIpAddresses = ["10.0.1.10", "10.0.1.11"]
request.VirtualPrivateCloud = vpc

# System disk configuration
system_disk = models.SystemDisk()
system_disk.DiskType = "CLOUD_PREMIUM"
system_disk.DiskSize = 50
request.SystemDisk = system_disk

# Data disk configuration
data_disk = models.DataDisk()
data_disk.DiskType = "CLOUD_SSD"
data_disk.DiskSize = 200
data_disk.DeleteWithInstance = True
request.DataDisks = [data_disk]

# Internet access configuration
internet = models.InternetAccessible()
internet.InternetChargeType = "TRAFFIC_POSTPAID_BY_HOUR"
internet.InternetMaxBandwidthOut = 100
internet.PublicIpAssigned = True
request.InternetAccessible = internet

# Login configuration
login = models.LoginSettings()
login.KeyIds = ["skey-12345678"]
request.LoginSettings = login

# Tag configuration
tag_spec = models.TagSpecification()
tag_spec.ResourceType = "instance"
tag_spec.Tags = [
    models.Tag(Key="Environment", Value="Production"),
    models.Tag(Key="Application", Value="WebServer")
]
request.TagSpecification = [tag_spec]

# Execute request
response = client.RunInstances(request)
print(f"Created instances: {response.InstanceIdSet}")

Response Processing:

# Query instances and process response
desc_request = models.DescribeInstancesRequest()
desc_response = client.DescribeInstances(desc_request)

print(f"Total instances: {desc_response.TotalCount}")

for instance in desc_response.InstanceSet:
    print(f"Instance {instance.InstanceId}:")
    print(f"  Name: {instance.InstanceName}")
    print(f"  Type: {instance.InstanceType}")
    print(f"  State: {instance.InstanceState}")
    print(f"  Private IPs: {instance.PrivateIpAddresses}")
    print(f"  Public IPs: {instance.PublicIpAddresses}")
    print(f"  Created: {instance.CreatedTime}")
    
    # Process tags
    if instance.Tags:
        print("  Tags:")
        for tag in instance.Tags:
            print(f"    {tag.Key}: {tag.Value}")
    
    # Process disks
    if instance.DataDisks:
        print("  Data Disks:")
        for disk in instance.DataDisks:
            print(f"    {disk.DiskType}: {disk.DiskSize}GB")

Model Serialization and Storage:

import json

# Serialize model to JSON for storage/transmission
instance_data = desc_response.to_json_string(indent=2)

# Store in file
with open("instances.json", "w") as f:
    f.write(instance_data)

# Load from file
with open("instances.json", "r") as f:
    json_data = f.read()

# Recreate model from JSON
new_response = models.DescribeInstancesResponse()
new_response.from_json_string(json_data)

# Use reconstructed data
print(f"Loaded {new_response.TotalCount} instances from file")

Filter Construction:

# Build complex filters for instance queries
request = models.DescribeInstancesRequest()

# Filter by zone
zone_filter = models.Filter()
zone_filter.Name = "zone"
zone_filter.Values = ["ap-shanghai-1", "ap-shanghai-2"]

# Filter by instance state
state_filter = models.Filter()
state_filter.Name = "instance-state-name"
state_filter.Values = ["running", "stopped"]

# Filter by tag
tag_filter = models.Filter()
tag_filter.Name = "tag:Environment"
tag_filter.Values = ["Production"]

# Combine filters
request.Filters = [zone_filter, state_filter, tag_filter]
request.Limit = 50

response = client.DescribeInstances(request)
print(f"Found {len(response.InstanceSet)} filtered instances")

Install with Tessl CLI

npx tessl i tessl/pypi-tencentcloud-sdk-python

docs

authentication.md

client-infrastructure.md

configuration.md

data-models.md

error-handling.md

index.md

service-clients.md

tile.json