# coding: utf-8

import os

from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkvpc.v2 import ListVpcsRequest, VpcClient
from huaweicloudsdkvpc.v2.region.vpc_region import VpcRegion
from huaweicloudsdkcore.exceptions import exceptions

if __name__ == "__main__":
    # Configure authentication
    # Do not hard-code authentication information into the code, as this may pose a security risk
    # Authentication can be configured through environment variables and other methods. Please refer to Chapter 2.4 Authentication Management
    credentials = BasicCredentials(os.getenv("HUAWEICLOUD_SDK_AK"), os.getenv("HUAWEICLOUD_SDK_SK"))

    # Create a service client
    client = VpcClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(VpcRegion.value_of("cn-north-4")) \
        .build()
    
    # Send the request and get the response
    try:
        request = ListVpcsRequest()
        response = client.list_vpcs(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

# coding: utf-8

import os
import logging

from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkcore.http.http_config import HttpConfig
from huaweicloudsdkcore.http.http_handler import HttpHandler
from huaweicloudsdkvpc.v2 import VpcClient, ListVpcsRequest
from huaweicloudsdkvpc.v2.region.vpc_region import VpcRegion
from huaweicloudsdkcore.exceptions import exceptions

if __name__ == "__main__":
    # Configure authentication
    # Do not hard-code authentication information into the code, as this may pose a security risk
    # Authentication can be configured through environment variables and other methods. Please refer to Chapter 2.4 Authentication Management
    # If project_id is not filled in, the SDK will automatically call the IAM service to query the project id corresponding to the region.
    credentials = BasicCredentials(os.getenv("HUAWEICLOUD_SDK_AK"), os.getenv("HUAWEICLOUD_SDK_SK"), project_id="{your projectId string}") \
            .with_iam_endpoint("https://iam.cn-north-4.myhuaweicloud.com")  # Configure the SDK built-in IAM service endpoint, default is https://iam.myhuaweicloud.com

    # Use default configuration
    http_config = HttpConfig.get_default_config()
    # Configure whether to ignore the SSL certificate verification, default is false
    http_config.ignore_ssl_verification = True
    # Configure CA certificate file
    http_config.ssl_ca_cert = '/path/to/certfile'
    # The default connection timeout is 60 seconds, the default read timeout is 120 seconds
    http_config.timeout = (60, 120)
    # Configure proxy as needed
    # Replace the proxy protocol, host and port in the example according to the actual situation
    http_config.proxy_protocol = 'http'
    http_config.proxy_host = 'proxy.huaweicloud.com'
    http_config.proxy_port = 80
    # Configure the username and password if the proxy requires authentication
    http_config.proxy_user = os.getenv("PROXY_USERNAME")
    http_config.proxy_password = os.getenv("PROXY_PASSWORD")

    # The HTTP handler is used to print the request and response, do not use it in the production environment
    def response_handler(**kwargs):
        response = kwargs.get("response")
        request = response.request

        info = "> Request %s %s HTTP/1.1" % (request.method, request.path_url) + "\n"
        if len(request.headers) != 0:
            info = info + "> Headers:" + "\n"
            for each in request.headers:
                info = info + "    %s: %s" % (each, request.headers[each]) + "\n"
        info = info + "> Body: %s" % request.body + "\n\n"
    
        info = info + "< Response HTTP/1.1 %s " % response.status_code + "\n"
        if len(response.headers) != 0:
            info = info + "< Headers:" + "\n"
            for each in response.headers:
                info = info + "    %s: %s" % (each, response.headers[each],) + "\n"
        info = info + "< Body: %s" % response.content
        print(info)

    http_handler = HttpHandler().add_response_handler(response_handler)

    // Create a service client
    client = VpcClient.new_builder() \
        .with_credentials(credentials) \  # Configure authentication
        .with_region(VpcRegion.value_of("cn-north-4")) \  # Configure region, it will throw a KeyError if the region does not exist
        .with_http_config(http_config) \  # Configure HTTP
        .with_stream_log(log_level=logging.INFO) \  # Configure request log output to console
        .with_file_log(path="test.log", log_level=logging.INFO) \  # Configure request log output to file
        .with_http_handler(http_handler) \  # Configure HTTP handler
        .build()

    # Send the request and get the response
    try:
        request = ListVpcsRequest()
        response = client.list_vpcs(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

from huaweicloudsdkcore.http.http_config import HttpConfig

#  Use default configuration
http_config = HttpConfig.get_default_config()

client = VpcClient.new_builder() \
    .with_http_config(http_config) \
    .build()

http_config = HttpConfig.get_default_config()
# Use Proxy if needed
# Replace the proxy protocol, host and port in the example according to the actual situation
http_config.proxy_protocol = 'http'
http_config.proxy_host = 'proxy.huaweicloud.com'
http_config.proxy_port = 80
# Configure the username and password if the proxy requires authentication
# In this example, username and password are stored in environment variables. Please configure the environment variables PROXY_USERNAME and PROXY_PASSWORD before running this example.
http_config.proxy_user = os.getenv("PROXY_USERNAME")
http_config.proxy_password = os.getenv("PROXY_PASSWORD")

client = VpcClient.new_builder() \
    .with_http_config(http_config) \
    .build()

http_config = HttpConfig.get_default_config()
# The default connection timeout is 60 seconds, the default read timeout is 120 seconds
# Set the connection timeout and read timeout to 120 seconds
http_config.timeout = 120
# Set the connection timeout to 60 seconds and the read timeout to 120 seconds
http_config.timeout = (60, 120)

client = VpcClient.new_builder() \
    .with_http_config(http_config) \
    .build()

http_config = HttpConfig.get_default_config()
# Skip SSL certifaction checking while using https protocol if needed
http_config.ignore_ssl_verification = True
# Configure the server's CA certificate for the SDK to verify the legitimacy of the server
http_config.ssl_ca_cert = ssl_ca_cert

client = VpcClient.new_builder() \
    .with_http_config(http_config) \
    .build()

# Regional services
ak = os.getenv("HUAWEICLOUD_SDK_AK")
sk = os.getenv("HUAWEICLOUD_SDK_SK")
project_id = "{your projectId string}"

basic_credentials = BasicCredentials(ak, sk, project_id)

# Global services
ak = os.getenv("HUAWEICLOUD_SDK_AK")
sk = os.getenv("HUAWEICLOUD_SDK_SK")
domain_id = "{your domainId string}"

global_credentials = GlobalCredentials(ak, sk, domain_id)

# Regional services
ak = os.getenv("HUAWEICLOUD_SDK_AK")
sk = os.getenv("HUAWEICLOUD_SDK_SK")
security_token = os.getenv("HUAWEICLOUD_SDK_SECURITY_TOKEN")
project_id = "{your projectId string}"

basic_credentials = BasicCredentials(ak, sk, project_id).with_security_token(security_token)

# Global services
ak = os.getenv("HUAWEICLOUD_SDK_AK")
sk = os.getenv("HUAWEICLOUD_SDK_SK")
security_token = os.getenv("HUAWEICLOUD_SDK_SECURITY_TOKEN")
domain_id = "{your domainId string}"

global_credentials = GlobalCredentials(ak, sk, domain_id).with_security_token(security_token)

from huaweicloudsdkcore.auth.credentials import BasicCredentials, GlobalCredentials

# Regional service
basic_cred = BasicCredentials() \
    .with_idp_id(idp_id) \
    .with_id_token_file(id_token_file) \
    .with_project_id(project_id)

# Global service
global_cred = GlobalCredentials() \
    .with_idp_id(idp_id) \
    .with_id_token_file(id_token_file) \
    .with_domain_id(domain_id)

from huaweicloudsdkcore.auth.provider import EnvCredentialProvider

# basic
basic_provider = EnvCredentialProvider.get_basic_credential_env_provider()
basic_cred = basic_provider.get_credentials()

# global
global_provider = EnvCredentialProvider.get_global_credential_env_provider()
global_cred = global_provider.get_credentials()

from huaweicloudsdkcore.auth.provider import EnvCredentialProvider

# basic
basic_provider = EnvCredentialProvider.get_basic_credential_env_provider()
basic_cred = basic_provider.get_credentials()

# global
global_provider = EnvCredentialProvider.get_global_credential_env_provider()
global_cred = global_provider.get_credentials()

from huaweicloudsdkcore.auth.provider import ProfileCredentialProvider

# basic
basic_provider = ProfileCredentialProvider.get_basic_credential_profile_provider()
basic_cred = basic_provider.get_credentials()

# global
global_provider = ProfileCredentialProvider.get_global_credential_profile_provider()
global_cred = global_provider.get_credentials()

from huaweicloudsdkcore.auth.provider import ProfileCredentialProvider

# basic
basic_provider = ProfileCredentialProvider.get_basic_credential_profile_provider()
basic_cred = basic_provider.get_credentials()

# global
global_provider = ProfileCredentialProvider.get_global_credential_profile_provider()
global_cred = global_provider.get_credentials()

from huaweicloudsdkcore.auth.provider import MetadataCredentialProvider

# basic
basic_provider = MetadataCredentialProvider.get_basic_credential_metadata_provider()
basic_cred = basic_provider.get_credentials()

# global
global_provider = MetadataCredentialProvider.get_global_credential_metadata_provider()
global_cred = global_provider.get_credentials()

from huaweicloudsdkcore.auth.provider import CredentialProviderChain

# basic
basic_chain = CredentialProviderChain.get_basic_credential_provider_chain()
basic_cred = basic_chain.get_credentials()

# global
global_chain = CredentialProviderChain.get_global_credential_provider_chain()
global_cred = global_chain.get_credentials()

from huaweicloudsdkcore.auth.provider import CredentialProviderChain, ProfileCredentialProvider, MetadataCredentialProvider

providers = [
    ProfileCredentialProvider.get_basic_credential_profile_provider(),
    MetadataCredentialProvider.get_basic_credential_metadata_provider()
]

chain = CredentialProviderChain(providers)
credentials = chain.get_credentials()

# Specify the endpoint, take the endpoint of VPC service in region of cn-north-4 for example
endpoint = "https://vpc.cn-north-4.myhuaweicloud.com"

# Initialize the credentials, you should provide project_id or domain_id in this way, take initializing BasicCredentials for example
ak = os.getenv("HUAWEICLOUD_SDK_AK")
sk = os.getenv("HUAWEICLOUD_SDK_SK")
project_id = "{your projectId string}"
basic_credentials = BasicCredentials(ak, sk, project_id)

# Initialize specified service client instance, take initializing the regional service VPC's VpcClient for example
client = VpcClient.new_builder() \
    .with_http_config(config) \
    .with_credentials(basic_credentials) \
    .with_endpoint(endpoint) \
    .build()

import os
# dependency for region module
from huaweicloudsdkiam.v3.region.iam_region import IamRegion

# Initialize the credentials, project_id or domain_id could be unassigned in this situation
# Take initializing GlobalCredentials for example
ak = os.getenv("HUAWEICLOUD_SDK_AK")
sk = os.getenv("HUAWEICLOUD_SDK_SK")
global_credentials = GlobalCredentials(ak, sk)

# Initialize specified service client instance
# Take initializing the global service IAM's IamClient for example
client = IamClient.new_builder() \
    .with_http_config(config) \
    .with_credentials(global_credentials) \
    .with_region(IamRegion.CN_NORTH_4) \
    .build()

import os

from huaweicloudsdkcore.auth.credentials import BasicCredentials

ak = os.getenv("HUAWEICLOUD_SDK_AK")
sk = os.getenv("HUAWEICLOUD_SDK_SK")
iam_endpoint = "https://iam.cn-north-4.myhuaweicloud.com"
credentials = BasicCredentials(ak, sk).with_iam_endpoint(iam_endpoint)

from huaweicloudsdkcore.region.region import Region
from huaweicloudsdkecs.v2 import EcsClient

# Create a region with custom region id and endpoint
region = Region("cn-north-9", "https://ecs.cn-north-9.myhuaweicloud.com")

client = EcsClient.new_builder() \
    .with_credentials(credentials) \
    .with_region(region) \
    .build()

from huaweicloudsdkecs.v2.region.ecs_region import EcsRegion

region1 = EcsRegion.value_of("cn-north-1")
region2 = EcsRegion.value_of("cn-north-9")

# Initialize a request and print response, take interface of ListVpcs for example
request = ListVpcsRequest(limit=1)

response = client.list_vpcs(request)
print(response)

# handle exceptions
try:
    request = ListVpcsRequest(limit=1)
    response = client.list_vpcs(request)
    print(response)
except exception.ServiceResponseException as e:
    print(e.status_code)
    print(e.request_id)
    print(e.error_code)
    print(e.error_msg)

request = ListVpcsRequest(limit=1)
# original response json string
response = client.list_vpcs(request)
print(response)
# response object
response_obj = response.to_json_object()
print(response_obj["vpcs"])

# Initialize asynchronous client, take VpcAsyncClient for example
client = VpcAsyncClient.new_builder() \
    .with_http_config(config) \
    .with_credentials(basic_credentials) \
    .with_endpoint(endpoint) \
    .build()

# send asynchronous request
request = ListVpcsRequest(limit=1)
response = client.list_vpcs_async(request)

# get asynchronous response
print(response.result())

client = VpcClient.new_builder() \
    .with_file_log(path="test.log", log_level=logging.INFO) \  # Write log files
    .with_stream_log(log_level=logging.INFO) \                 # Write log to console
    .build()

%(asctime)s %(thread)d %(name)s %(filename)s %(lineno)d %(levelname)s %(message)s

from huaweicloudsdkcore.http.http_handler import HttpHandler


def response_handler(**kwargs):
    response = kwargs.get("response")
    request = response.request

    info = "> Request %s %s HTTP/1.1" % (request.method, request.path_url) + "\n"
    if len(request.headers) != 0:
        info = info + "> Headers:" + "\n"
        for each in request.headers:
            info = info + "    %s: %s" % (each, request.headers[each]) + "\n"
    info = info + "> Body: %s" % request.body + "\n\n"

    info = info + "< Response HTTP/1.1 %s " % response.status_code + "\n"
    if len(response.headers) != 0:
        info = info + "< Headers:" + "\n"
        for each in response.headers:
            info = info + "    %s: %s" % (each, response.headers[each],) + "\n"
    info = info + "< Body: %s" % response.content
    print(info)


if __name__ == "__main__":
    http_handler = HttpHandler().add_response_handler(response_handler)
    client = VpcClient.new_builder() \
    	.with_http_handler(http_handler) \
        .build()

client = VpcClient.new_builder() \
    .with_credentials(credentials) \
    .with_region(VpcRegion.value_of("cn-north-4")) \
    .build()

request = ListVpcsRequest()
response = client.list_vpcs_invoker(request) \
    # Custom request headers
    .add_header("key1", "value1") \
    .add_header("key2", "value2") \
    .invoke()
print(response)

client = VpcAsyncClient.new_builder() \
    .with_credentials(credentials) \
    .with_region(VpcRegion.value_of("cn-north-4")) \
    .build()

request = ListVpcsRequest()
response = client.list_vpcs_async_invoker(request) \
    # Custom request headers
    .add_header("key1", "value1") \
    .add_header("key2", "value2") \
    .invoke().result()
print(response)

from huaweicloudsdkcore.exceptions.exceptions import ConnectionException, ServerResponseException
from huaweicloudsdkvpc.v2 import ListVpcsRequest
from huaweicloudsdkvpc.v2.vpc_client import VpcClient

from huaweicloudsdkcore.retry.backoff_strategy import BackoffStrategies


client = VpcClient.new_builder() \
    .with_credentials(credentials) \
    .with_region(VpcRegion.value_of("cn-north-4")) \
    .build()
    
request = ListVpcsRequest()
# Retry on connection exception, max retry times is 3, retry interval strategy is immediate retry.
response = client.list_vpcs_invoker(request).with_retry(
    retry_condition=lambda resp, exc: isinstance(exc, ConnectionException),
    max_retries=3,
    backoff_strategy=BackoffStrategies.NONE
).invoke()

# Retry on server response exception, max retry times is 3, retry interval strategy is equal jitter backoff strategy.
# response = client.list_vpcs_invoker(request).with_retry(
#     retry_condition=lambda resp, exc: isinstance(exc, ServerResponseException) and exc.status_code == 503,
#     max_retries=10,
#     backoff_strategy=BackoffStrategies.EQUAL_JITTER
# ).invoke()

# coding: utf-8

import os

from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkcore.exceptions import exceptions
from huaweicloudsdkcore.http.http_config import HttpConfig
from huaweicloudsdkcore.http.formdata import FormFile
from huaweicloudsdkdsc.v1 import *


def create_image_watermark(client):

    try:
        request = CreateImageWatermarkRequest()
        # Open the file in mode "rb", create a Formfile object.
        image_file = FormFile(open("demo.jpg", "rb"))
        body = CreateImageWatermarkRequestBody(file=image_file, blind_watermark="test_watermark")
        request.body = body
        response = client.create_image_watermark(request)
        image_file.close()
        
        # Define the method of downloading files.
        def save(stream):
            with open("result.jpg", "wb") as f:
                f.write(stream.content)
        # Download the file.
        response.consume_download_stream(save)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)


if __name__ == "__main__":
    ak = os.getenv("HUAWEICLOUD_SDK_AK")
    sk = os.getenv("HUAWEICLOUD_SDK_SK")
    endpoint = "{your endpoint}"
    project_id = "{your project id}"
    config = HttpConfig.get_default_config()
    config.ignore_ssl_verification = True
    credentials = BasicCredentials(ak, sk, project_id)
    dsc_client = DscClient.new_builder() \
        .with_http_config(config) \
        .with_credentials(credentials) \
        .with_endpoint(endpoint) \
        .build()
    
    create_image_watermark(dsc_client)