Python msrest.Serializer方法代码示例

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(self, credentials, base_url=None):

        self.config = TokenApiClientConfiguration(credentials, base_url)
        super(TokenApiClient, self).__init__(self.config.credentials, self.config)

        client_models = {
            k: v for k, v in models.__dict__.items() if isinstance(v, type)
        }
        self.api_version = "token"
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.bot_sign_in = BotSignInOperations(
            self._client, self.config, self._serialize, self._deserialize
        )
        self.user_token = UserTokenOperations(
            self._client, self.config, self._serialize, self._deserialize
        ) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(self, credentials, base_url=None):

        self.config = TokenApiClientConfiguration(credentials, base_url)
        super(TokenApiClient, self).__init__(self.config)

        client_models = {
            k: v for k, v in models.__dict__.items() if isinstance(v, type)
        }
        self.api_version = "token"
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.bot_sign_in = BotSignInOperations(
            self._client, self.config, self._serialize, self._deserialize
        )
        self.user_token = UserTokenOperations(
            self._client, self.config, self._serialize, self._deserialize
        ) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(self, credentials, base_url=None):

        self.config = ConnectorClientConfiguration(credentials, base_url)
        super(ConnectorClient, self).__init__(self.config)

        client_models = {
            k: v for k, v in models.__dict__.items() if isinstance(v, type)
        }
        self.api_version = "v3"
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.attachments = AttachmentsOperations(
            self._client, self.config, self._serialize, self._deserialize
        )
        self.conversations = ConversationsOperations(
            self._client, self.config, self._serialize, self._deserialize
        ) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def blob_services(self):
        """Instance depends on the API version:

           * 2018-07-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2018_07_01.operations.BlobServicesOperations>`
           * 2018-11-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2018_11_01.operations.BlobServicesOperations>`
           * 2019-04-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2019_04_01.operations.BlobServicesOperations>`
           * 2019-06-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2019_06_01.operations.BlobServicesOperations>`
        """
        api_version = self._get_api_version('blob_services')
        if api_version == '2018-07-01':
            from .v2018_07_01.operations import BlobServicesOperations as OperationClass
        elif api_version == '2018-11-01':
            from .v2018_11_01.operations import BlobServicesOperations as OperationClass
        elif api_version == '2019-04-01':
            from .v2019_04_01.operations import BlobServicesOperations as OperationClass
        elif api_version == '2019-06-01':
            from .v2019_06_01.operations import BlobServicesOperations as OperationClass
        else:
            raise NotImplementedError("APIVersion {} is not available".format(api_version))
        return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def management_policies(self):
        """Instance depends on the API version:

           * 2018-07-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2018_07_01.operations.ManagementPoliciesOperations>`
           * 2018-11-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2018_11_01.operations.ManagementPoliciesOperations>`
           * 2019-04-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2019_04_01.operations.ManagementPoliciesOperations>`
           * 2019-06-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2019_06_01.operations.ManagementPoliciesOperations>`
        """
        api_version = self._get_api_version('management_policies')
        if api_version == '2018-07-01':
            from .v2018_07_01.operations import ManagementPoliciesOperations as OperationClass
        elif api_version == '2018-11-01':
            from .v2018_11_01.operations import ManagementPoliciesOperations as OperationClass
        elif api_version == '2019-04-01':
            from .v2019_04_01.operations import ManagementPoliciesOperations as OperationClass
        elif api_version == '2019-06-01':
            from .v2019_06_01.operations import ManagementPoliciesOperations as OperationClass
        else:
            raise NotImplementedError("APIVersion {} is not available".format(api_version))
        return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def usages(self):
        """Instance depends on the API version:

           * 2018-03-01-preview: :class:`UsagesOperations<azure.mgmt.storage.v2018_03_01_preview.operations.UsagesOperations>`
           * 2018-07-01: :class:`UsagesOperations<azure.mgmt.storage.v2018_07_01.operations.UsagesOperations>`
           * 2018-11-01: :class:`UsagesOperations<azure.mgmt.storage.v2018_11_01.operations.UsagesOperations>`
           * 2019-04-01: :class:`UsagesOperations<azure.mgmt.storage.v2019_04_01.operations.UsagesOperations>`
           * 2019-06-01: :class:`UsagesOperations<azure.mgmt.storage.v2019_06_01.operations.UsagesOperations>`
        """
        api_version = self._get_api_version('usages')
        if api_version == '2018-03-01-preview':
            from .v2018_03_01_preview.operations import UsagesOperations as OperationClass
        elif api_version == '2018-07-01':
            from .v2018_07_01.operations import UsagesOperations as OperationClass
        elif api_version == '2018-11-01':
            from .v2018_11_01.operations import UsagesOperations as OperationClass
        elif api_version == '2019-04-01':
            from .v2019_04_01.operations import UsagesOperations as OperationClass
        elif api_version == '2019-06-01':
            from .v2019_06_01.operations import UsagesOperations as OperationClass
        else:
            raise NotImplementedError("APIVersion {} is not available".format(api_version))
        return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(
            self, credentials, subscription_id, base_url=None):

        self.config = HybridComputeManagementClientConfiguration(credentials, subscription_id, base_url)
        super(HybridComputeManagementClient, self).__init__(self.config.credentials, self.config)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self.api_version = '2019-08-02-preview'
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.machines = MachinesOperations(
            self._client, self.config, self._serialize, self._deserialize)
        self.machine_extensions = MachineExtensionsOperations(
            self._client, self.config, self._serialize, self._deserialize)
        self.operations = Operations(
            self._client, self.config, self._serialize, self._deserialize) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(
        self,
        credential: "TokenCredential",
        subscription_id: str,
        acceptlanguage: Optional[str] = None,
        base_url: Optional[str] = None,
        **kwargs: Any
    ) -> None:
        if not base_url:
            base_url = 'https://management.azure.com'
        self._config = StorageImportExportConfiguration(credential, subscription_id, acceptlanguage, **kwargs)
        self._client = AsyncPipelineClient(base_url=base_url, config=self._config, **kwargs)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.location = LocationOperations(
            self._client, self._config, self._serialize, self._deserialize)
        self.job = JobOperations(
            self._client, self._config, self._serialize, self._deserialize)
        self.bit_locker_key = BitLockerKeyOperations(
            self._client, self._config, self._serialize, self._deserialize)
        self.operation = OperationOperations(
            self._client, self._config, self._serialize, self._deserialize) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(
        self,
        credential: "AsyncTokenCredential",
        subscription_id: str,
        base_url: Optional[str] = None,
        **kwargs: Any
    ) -> None:
        if not base_url:
            base_url = 'https://management.azure.com'
        self._config = HealthcareApisManagementClientConfiguration(credential, subscription_id, **kwargs)
        self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.service = ServiceOperations(
            self._client, self._config, self._serialize, self._deserialize)
        self.operation = OperationOperations(
            self._client, self._config, self._serialize, self._deserialize)
        self.operation_result = OperationResultOperations(
            self._client, self._config, self._serialize, self._deserialize) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(
            self, credentials, subscription_id, provider_name, resource_type, resource_name, base_url=None):

        self.config = OperationsManagementClientConfiguration(credentials, subscription_id, provider_name, resource_type, resource_name, base_url)
        super(OperationsManagementClient, self).__init__(self.config.credentials, self.config)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self.api_version = '2015-11-01-preview'
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.solutions = SolutionsOperations(
            self._client, self.config, self._serialize, self._deserialize)
        self.management_associations = ManagementAssociationsOperations(
            self._client, self.config, self._serialize, self._deserialize)
        self.management_configurations = ManagementConfigurationsOperations(
            self._client, self.config, self._serialize, self._deserialize)
        self.operations = Operations(
            self._client, self.config, self._serialize, self._deserialize) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(
            self, credentials, base_url=None):

        self.config = SubscriptionClientConfiguration(credentials, base_url)
        self._client = ServiceClient(self.config.credentials, self.config)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.operations = Operations(
            self._client, self.config, self._serialize, self._deserialize)
        self.subscription_operations = SubscriptionOperations(
            self._client, self.config, self._serialize, self._deserialize)
        self.subscription_factory = SubscriptionFactoryOperations(
            self._client, self.config, self._serialize, self._deserialize)
        self.subscriptions = SubscriptionsOperations(
            self._client, self.config, self._serialize, self._deserialize)
        self.tenants = TenantsOperations(
            self._client, self.config, self._serialize, self._deserialize) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(
        self,
        credential: "AsyncTokenCredential",
        subscription_id: str,
        base_url: Optional[str] = None,
        **kwargs: Any
    ) -> None:
        if not base_url:
            base_url = 'https://management.azure.com'
        self._config = AzureDedicatedHSMResourceProviderConfiguration(credential, subscription_id, **kwargs)
        self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.dedicated_hsm = DedicatedHsmOperations(
            self._client, self._config, self._serialize, self._deserialize) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def __init__(
        self,
        credential,  # type: "TokenCredential"
        subscription_id,  # type: str
        base_url=None,  # type: Optional[str]
        **kwargs  # type: Any
    ):
        # type: (...) -> None
        if not base_url:
            base_url = 'https://management.azure.com'
        self._config = AzureDedicatedHSMResourceProviderConfiguration(credential, subscription_id, **kwargs)
        self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.dedicated_hsm = DedicatedHsmOperations(
            self._client, self._config, self._serialize, self._deserialize) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def ddos_protection_plans(self):
        """Instance depends on the API version:

           * 2018-02-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_02_01.operations.DdosProtectionPlansOperations>`
           * 2018-04-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_04_01.operations.DdosProtectionPlansOperations>`
           * 2018-06-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_06_01.operations.DdosProtectionPlansOperations>`
           * 2018-07-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_07_01.operations.DdosProtectionPlansOperations>`
           * 2018-08-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_08_01.operations.DdosProtectionPlansOperations>`
        """
        api_version = self._get_api_version('ddos_protection_plans')
        if api_version == '2018-02-01':
            from .v2018_02_01.operations import DdosProtectionPlansOperations as OperationClass
        elif api_version == '2018-04-01':
            from .v2018_04_01.operations import DdosProtectionPlansOperations as OperationClass
        elif api_version == '2018-06-01':
            from .v2018_06_01.operations import DdosProtectionPlansOperations as OperationClass
        elif api_version == '2018-07-01':
            from .v2018_07_01.operations import DdosProtectionPlansOperations as OperationClass
        elif api_version == '2018-08-01':
            from .v2018_08_01.operations import DdosProtectionPlansOperations as OperationClass
        else:
            raise NotImplementedError("APIVersion {} is not available".format(api_version))
        return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version))) 

# 需要导入模块: import msrest [as 别名]
# 或者: from msrest import Serializer [as 别名]
def express_route_cross_connection_peerings(self):
        """Instance depends on the API version:

           * 2018-02-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_02_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`
           * 2018-04-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_04_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`
           * 2018-06-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_06_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`
           * 2018-07-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_07_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`
           * 2018-08-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_08_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`
        """
        api_version = self._get_api_version('express_route_cross_connection_peerings')
        if api_version == '2018-02-01':
            from .v2018_02_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
        elif api_version == '2018-04-01':
            from .v2018_04_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
        elif api_version == '2018-06-01':
            from .v2018_06_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
        elif api_version == '2018-07-01':
            from .v2018_07_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
        elif api_version == '2018-08-01':
            from .v2018_08_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
        else:
            raise NotImplementedError("APIVersion {} is not available".format(api_version))
        return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))