diff --git a/sdk/automation/azure-mgmt-automation/_meta.json b/sdk/automation/azure-mgmt-automation/_meta.json index d0d76552566a..2f22915a7717 100644 --- a/sdk/automation/azure-mgmt-automation/_meta.json +++ b/sdk/automation/azure-mgmt-automation/_meta.json @@ -1,11 +1,11 @@ { - "autorest": "3.7.2", + "autorest": "3.8.4", "use": [ - "@autorest/python@5.16.0", - "@autorest/modelerfour@4.19.3" + "@autorest/python@6.0.1", + "@autorest/modelerfour@4.23.5" ], - "commit": "fc2245b8f0fe6f17628e3b5a306b4b150c73cff0", + "commit": "0d88dc64510973831736cccd56d863f346f05784", "repository_url": "https://github.com/Azure/azure-rest-api-specs", - "autorest_command": "autorest specification/automation/resource-manager/readme.md --python --python-sdks-folder=/home/vsts/work/1/azure-sdk-for-python/sdk --python3-only --use=@autorest/python@5.16.0 --use=@autorest/modelerfour@4.19.3 --version=3.7.2", + "autorest_command": "autorest specification/automation/resource-manager/readme.md --models-mode=msrest --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.0.1 --use=@autorest/modelerfour@4.23.5 --version=3.8.4 --version-tolerant=False", "readme": "specification/automation/resource-manager/readme.md" } \ No newline at end of file diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/__init__.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/__init__.py index a5838dfd5d0e..927eb79b7289 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/__init__.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/__init__.py @@ -17,7 +17,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['AutomationClient'] + +__all__ = ["AutomationClient"] __all__.extend([p for p in _patch_all if p not in __all__]) _patch_sdk() diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_automation_client.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_automation_client.py index c555af38b201..4bd924535b33 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_automation_client.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_automation_client.py @@ -9,20 +9,70 @@ from copy import deepcopy from typing import Any, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from . import models from ._configuration import AutomationClientConfiguration -from .operations import ActivityOperations, AgentRegistrationInformationOperations, AutomationAccountOperations, AutomationClientOperationsMixin, CertificateOperations, ConnectionOperations, ConnectionTypeOperations, CredentialOperations, DscCompilationJobOperations, DscCompilationJobStreamOperations, DscConfigurationOperations, DscNodeConfigurationOperations, DscNodeOperations, FieldsOperations, HybridRunbookWorkerGroupOperations, HybridRunbookWorkersOperations, JobOperations, JobScheduleOperations, JobStreamOperations, KeysOperations, LinkedWorkspaceOperations, ModuleOperations, NodeCountInformationOperations, NodeReportsOperations, ObjectDataTypesOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, Python2PackageOperations, RunbookDraftOperations, RunbookOperations, ScheduleOperations, SoftwareUpdateConfigurationMachineRunsOperations, SoftwareUpdateConfigurationRunsOperations, SoftwareUpdateConfigurationsOperations, SourceControlOperations, SourceControlSyncJobOperations, SourceControlSyncJobStreamsOperations, StatisticsOperations, TestJobOperations, TestJobStreamsOperations, UsagesOperations, VariableOperations, WatcherOperations, WebhookOperations +from ._serialization import Deserializer, Serializer +from .operations import ( + ActivityOperations, + AgentRegistrationInformationOperations, + AutomationAccountOperations, + AutomationClientOperationsMixin, + CertificateOperations, + ConnectionOperations, + ConnectionTypeOperations, + CredentialOperations, + DeletedAutomationAccountsOperations, + DscCompilationJobOperations, + DscCompilationJobStreamOperations, + DscConfigurationOperations, + DscNodeConfigurationOperations, + DscNodeOperations, + FieldsOperations, + HybridRunbookWorkerGroupOperations, + HybridRunbookWorkersOperations, + JobOperations, + JobScheduleOperations, + JobStreamOperations, + KeysOperations, + LinkedWorkspaceOperations, + ModuleOperations, + NodeCountInformationOperations, + NodeReportsOperations, + ObjectDataTypesOperations, + Operations, + PrivateEndpointConnectionsOperations, + PrivateLinkResourcesOperations, + Python2PackageOperations, + Python3PackageOperations, + RunbookDraftOperations, + RunbookOperations, + ScheduleOperations, + SoftwareUpdateConfigurationMachineRunsOperations, + SoftwareUpdateConfigurationRunsOperations, + SoftwareUpdateConfigurationsOperations, + SourceControlOperations, + SourceControlSyncJobOperations, + SourceControlSyncJobStreamsOperations, + StatisticsOperations, + TestJobOperations, + TestJobStreamsOperations, + UsagesOperations, + VariableOperations, + WatcherOperations, + WebhookOperations, +) if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential -class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=too-many-instance-attributes + +class AutomationClient( + AutomationClientOperationsMixin +): # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes """Automation Client. :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations @@ -31,8 +81,6 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :ivar private_link_resources: PrivateLinkResourcesOperations operations :vartype private_link_resources: azure.mgmt.automation.operations.PrivateLinkResourcesOperations - :ivar python2_package: Python2PackageOperations operations - :vartype python2_package: azure.mgmt.automation.operations.Python2PackageOperations :ivar agent_registration_information: AgentRegistrationInformationOperations operations :vartype agent_registration_information: azure.mgmt.automation.operations.AgentRegistrationInformationOperations @@ -40,9 +88,6 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :vartype dsc_node: azure.mgmt.automation.operations.DscNodeOperations :ivar node_reports: NodeReportsOperations operations :vartype node_reports: azure.mgmt.automation.operations.NodeReportsOperations - :ivar dsc_node_configuration: DscNodeConfigurationOperations operations - :vartype dsc_node_configuration: - azure.mgmt.automation.operations.DscNodeConfigurationOperations :ivar dsc_compilation_job: DscCompilationJobOperations operations :vartype dsc_compilation_job: azure.mgmt.automation.operations.DscCompilationJobOperations :ivar dsc_compilation_job_stream: DscCompilationJobStreamOperations operations @@ -51,14 +96,18 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :ivar node_count_information: NodeCountInformationOperations operations :vartype node_count_information: azure.mgmt.automation.operations.NodeCountInformationOperations - :ivar source_control: SourceControlOperations operations - :vartype source_control: azure.mgmt.automation.operations.SourceControlOperations - :ivar source_control_sync_job: SourceControlSyncJobOperations operations - :vartype source_control_sync_job: - azure.mgmt.automation.operations.SourceControlSyncJobOperations - :ivar source_control_sync_job_streams: SourceControlSyncJobStreamsOperations operations - :vartype source_control_sync_job_streams: - azure.mgmt.automation.operations.SourceControlSyncJobStreamsOperations + :ivar watcher: WatcherOperations operations + :vartype watcher: azure.mgmt.automation.operations.WatcherOperations + :ivar software_update_configurations: SoftwareUpdateConfigurationsOperations operations + :vartype software_update_configurations: + azure.mgmt.automation.operations.SoftwareUpdateConfigurationsOperations + :ivar webhook: WebhookOperations operations + :vartype webhook: azure.mgmt.automation.operations.WebhookOperations + :ivar deleted_automation_accounts: DeletedAutomationAccountsOperations operations + :vartype deleted_automation_accounts: + azure.mgmt.automation.operations.DeletedAutomationAccountsOperations + :ivar python3_package: Python3PackageOperations operations + :vartype python3_package: azure.mgmt.automation.operations.Python3PackageOperations :ivar automation_account: AutomationAccountOperations operations :vartype automation_account: azure.mgmt.automation.operations.AutomationAccountOperations :ivar statistics: StatisticsOperations operations @@ -75,9 +124,21 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :vartype connection_type: azure.mgmt.automation.operations.ConnectionTypeOperations :ivar credential: CredentialOperations operations :vartype credential: azure.mgmt.automation.operations.CredentialOperations + :ivar dsc_configuration: DscConfigurationOperations operations + :vartype dsc_configuration: azure.mgmt.automation.operations.DscConfigurationOperations + :ivar dsc_node_configuration: DscNodeConfigurationOperations operations + :vartype dsc_node_configuration: + azure.mgmt.automation.operations.DscNodeConfigurationOperations + :ivar hybrid_runbook_workers: HybridRunbookWorkersOperations operations + :vartype hybrid_runbook_workers: + azure.mgmt.automation.operations.HybridRunbookWorkersOperations :ivar hybrid_runbook_worker_group: HybridRunbookWorkerGroupOperations operations :vartype hybrid_runbook_worker_group: azure.mgmt.automation.operations.HybridRunbookWorkerGroupOperations + :ivar job: JobOperations operations + :vartype job: azure.mgmt.automation.operations.JobOperations + :ivar job_stream: JobStreamOperations operations + :vartype job_stream: azure.mgmt.automation.operations.JobStreamOperations :ivar job_schedule: JobScheduleOperations operations :vartype job_schedule: azure.mgmt.automation.operations.JobScheduleOperations :ivar linked_workspace: LinkedWorkspaceOperations operations @@ -90,30 +151,10 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :vartype object_data_types: azure.mgmt.automation.operations.ObjectDataTypesOperations :ivar fields: FieldsOperations operations :vartype fields: azure.mgmt.automation.operations.FieldsOperations - :ivar schedule: ScheduleOperations operations - :vartype schedule: azure.mgmt.automation.operations.ScheduleOperations - :ivar variable: VariableOperations operations - :vartype variable: azure.mgmt.automation.operations.VariableOperations - :ivar watcher: WatcherOperations operations - :vartype watcher: azure.mgmt.automation.operations.WatcherOperations - :ivar dsc_configuration: DscConfigurationOperations operations - :vartype dsc_configuration: azure.mgmt.automation.operations.DscConfigurationOperations - :ivar job: JobOperations operations - :vartype job: azure.mgmt.automation.operations.JobOperations - :ivar job_stream: JobStreamOperations operations - :vartype job_stream: azure.mgmt.automation.operations.JobStreamOperations :ivar operations: Operations operations :vartype operations: azure.mgmt.automation.operations.Operations - :ivar software_update_configurations: SoftwareUpdateConfigurationsOperations operations - :vartype software_update_configurations: - azure.mgmt.automation.operations.SoftwareUpdateConfigurationsOperations - :ivar software_update_configuration_runs: SoftwareUpdateConfigurationRunsOperations operations - :vartype software_update_configuration_runs: - azure.mgmt.automation.operations.SoftwareUpdateConfigurationRunsOperations - :ivar software_update_configuration_machine_runs: - SoftwareUpdateConfigurationMachineRunsOperations operations - :vartype software_update_configuration_machine_runs: - azure.mgmt.automation.operations.SoftwareUpdateConfigurationMachineRunsOperations + :ivar python2_package: Python2PackageOperations operations + :vartype python2_package: azure.mgmt.automation.operations.Python2PackageOperations :ivar runbook_draft: RunbookDraftOperations operations :vartype runbook_draft: azure.mgmt.automation.operations.RunbookDraftOperations :ivar runbook: RunbookOperations operations @@ -122,15 +163,29 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :vartype test_job_streams: azure.mgmt.automation.operations.TestJobStreamsOperations :ivar test_job: TestJobOperations operations :vartype test_job: azure.mgmt.automation.operations.TestJobOperations - :ivar webhook: WebhookOperations operations - :vartype webhook: azure.mgmt.automation.operations.WebhookOperations - :ivar hybrid_runbook_workers: HybridRunbookWorkersOperations operations - :vartype hybrid_runbook_workers: - azure.mgmt.automation.operations.HybridRunbookWorkersOperations - :param credential: Credential needed for the client to connect to Azure. + :ivar schedule: ScheduleOperations operations + :vartype schedule: azure.mgmt.automation.operations.ScheduleOperations + :ivar software_update_configuration_machine_runs: + SoftwareUpdateConfigurationMachineRunsOperations operations + :vartype software_update_configuration_machine_runs: + azure.mgmt.automation.operations.SoftwareUpdateConfigurationMachineRunsOperations + :ivar software_update_configuration_runs: SoftwareUpdateConfigurationRunsOperations operations + :vartype software_update_configuration_runs: + azure.mgmt.automation.operations.SoftwareUpdateConfigurationRunsOperations + :ivar source_control: SourceControlOperations operations + :vartype source_control: azure.mgmt.automation.operations.SourceControlOperations + :ivar source_control_sync_job: SourceControlSyncJobOperations operations + :vartype source_control_sync_job: + azure.mgmt.automation.operations.SourceControlSyncJobOperations + :ivar source_control_sync_job_streams: SourceControlSyncJobStreamsOperations operations + :vartype source_control_sync_job_streams: + azure.mgmt.automation.operations.SourceControlSyncJobStreamsOperations + :ivar variable: VariableOperations operations + :vartype variable: azure.mgmt.automation.operations.VariableOperations + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: Gets subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. + subscription. The subscription ID forms part of the URI for every service call. Required. :type subscription_id: str :param base_url: Service URL. Default value is "https://management.azure.com". :type base_url: str @@ -158,21 +213,11 @@ def __init__( self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.python2_package = Python2PackageOperations( - self._client, self._config, self._serialize, self._deserialize - ) self.agent_registration_information = AgentRegistrationInformationOperations( self._client, self._config, self._serialize, self._deserialize ) - self.dsc_node = DscNodeOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.node_reports = NodeReportsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.dsc_node_configuration = DscNodeConfigurationOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.dsc_node = DscNodeOperations(self._client, self._config, self._serialize, self._deserialize) + self.node_reports = NodeReportsOperations(self._client, self._config, self._serialize, self._deserialize) self.dsc_compilation_job = DscCompilationJobOperations( self._client, self._config, self._serialize, self._deserialize ) @@ -182,115 +227,72 @@ def __init__( self.node_count_information = NodeCountInformationOperations( self._client, self._config, self._serialize, self._deserialize ) - self.source_control = SourceControlOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.source_control_sync_job = SourceControlSyncJobOperations( + self.watcher = WatcherOperations(self._client, self._config, self._serialize, self._deserialize) + self.software_update_configurations = SoftwareUpdateConfigurationsOperations( self._client, self._config, self._serialize, self._deserialize ) - self.source_control_sync_job_streams = SourceControlSyncJobStreamsOperations( + self.webhook = WebhookOperations(self._client, self._config, self._serialize, self._deserialize) + self.deleted_automation_accounts = DeletedAutomationAccountsOperations( self._client, self._config, self._serialize, self._deserialize ) + self.python3_package = Python3PackageOperations(self._client, self._config, self._serialize, self._deserialize) self.automation_account = AutomationAccountOperations( self._client, self._config, self._serialize, self._deserialize ) - self.statistics = StatisticsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.usages = UsagesOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.keys = KeysOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.certificate = CertificateOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.connection = ConnectionOperations( + self.statistics = StatisticsOperations(self._client, self._config, self._serialize, self._deserialize) + self.usages = UsagesOperations(self._client, self._config, self._serialize, self._deserialize) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.certificate = CertificateOperations(self._client, self._config, self._serialize, self._deserialize) + self.connection = ConnectionOperations(self._client, self._config, self._serialize, self._deserialize) + self.connection_type = ConnectionTypeOperations(self._client, self._config, self._serialize, self._deserialize) + self.credential = CredentialOperations(self._client, self._config, self._serialize, self._deserialize) + self.dsc_configuration = DscConfigurationOperations( self._client, self._config, self._serialize, self._deserialize ) - self.connection_type = ConnectionTypeOperations( + self.dsc_node_configuration = DscNodeConfigurationOperations( self._client, self._config, self._serialize, self._deserialize ) - self.credential = CredentialOperations( + self.hybrid_runbook_workers = HybridRunbookWorkersOperations( self._client, self._config, self._serialize, self._deserialize ) self.hybrid_runbook_worker_group = HybridRunbookWorkerGroupOperations( self._client, self._config, self._serialize, self._deserialize ) - self.job_schedule = JobScheduleOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.job = JobOperations(self._client, self._config, self._serialize, self._deserialize) + self.job_stream = JobStreamOperations(self._client, self._config, self._serialize, self._deserialize) + self.job_schedule = JobScheduleOperations(self._client, self._config, self._serialize, self._deserialize) self.linked_workspace = LinkedWorkspaceOperations( self._client, self._config, self._serialize, self._deserialize ) - self.activity = ActivityOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.module = ModuleOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.activity = ActivityOperations(self._client, self._config, self._serialize, self._deserialize) + self.module = ModuleOperations(self._client, self._config, self._serialize, self._deserialize) self.object_data_types = ObjectDataTypesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.fields = FieldsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.schedule = ScheduleOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.variable = VariableOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.watcher = WatcherOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.dsc_configuration = DscConfigurationOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.job = JobOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.job_stream = JobStreamOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.software_update_configurations = SoftwareUpdateConfigurationsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.software_update_configuration_runs = SoftwareUpdateConfigurationRunsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.fields = FieldsOperations(self._client, self._config, self._serialize, self._deserialize) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.python2_package = Python2PackageOperations(self._client, self._config, self._serialize, self._deserialize) + self.runbook_draft = RunbookDraftOperations(self._client, self._config, self._serialize, self._deserialize) + self.runbook = RunbookOperations(self._client, self._config, self._serialize, self._deserialize) + self.test_job_streams = TestJobStreamsOperations(self._client, self._config, self._serialize, self._deserialize) + self.test_job = TestJobOperations(self._client, self._config, self._serialize, self._deserialize) + self.schedule = ScheduleOperations(self._client, self._config, self._serialize, self._deserialize) self.software_update_configuration_machine_runs = SoftwareUpdateConfigurationMachineRunsOperations( self._client, self._config, self._serialize, self._deserialize ) - self.runbook_draft = RunbookDraftOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.runbook = RunbookOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.test_job_streams = TestJobStreamsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.test_job = TestJobOperations( + self.software_update_configuration_runs = SoftwareUpdateConfigurationRunsOperations( self._client, self._config, self._serialize, self._deserialize ) - self.webhook = WebhookOperations( + self.source_control = SourceControlOperations(self._client, self._config, self._serialize, self._deserialize) + self.source_control_sync_job = SourceControlSyncJobOperations( self._client, self._config, self._serialize, self._deserialize ) - self.hybrid_runbook_workers = HybridRunbookWorkersOperations( + self.source_control_sync_job_streams = SourceControlSyncJobStreamsOperations( self._client, self._config, self._serialize, self._deserialize ) + self.variable = VariableOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> HttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -299,7 +301,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request :param request: The network request you want to make. Required. :type request: ~azure.core.rest.HttpRequest diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_configuration.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_configuration.py index 4d1356d8bcfa..d750ae2a0bd8 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_configuration.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_configuration.py @@ -25,19 +25,14 @@ class AutomationClientConfiguration(Configuration): # pylint: disable=too-many- Note that all parameters used to create this instance are saved as instance attributes. - :param credential: Credential needed for the client to connect to Azure. + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: Gets subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. + subscription. The subscription ID forms part of the URI for every service call. Required. :type subscription_id: str """ - def __init__( - self, - credential: "TokenCredential", - subscription_id: str, - **kwargs: Any - ) -> None: + def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(AutomationClientConfiguration, self).__init__(**kwargs) if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -46,23 +41,24 @@ def __init__( self.credential = credential self.subscription_id = subscription_id - self.credential_scopes = kwargs.pop('credential_scopes', ['https://management.azure.com/.default']) - kwargs.setdefault('sdk_moniker', 'mgmt-automation/{}'.format(VERSION)) + self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-automation/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> None - self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) - self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) - self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) - self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) - self.http_logging_policy = kwargs.get('http_logging_policy') or ARMHttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) + self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") if self.credential and not self.authentication_policy: - self.authentication_policy = ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs) + self.authentication_policy = ARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_patch.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_patch.py index 0ad201a8c586..f7dd32510333 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_patch.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_patch.py @@ -10,6 +10,7 @@ __all__: List[str] = [] # Add all objects you want publicly available to users at this package level + def patch_sdk(): """Do not remove from this file. diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_serialization.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_serialization.py new file mode 100644 index 000000000000..648f84cc4e65 --- /dev/null +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_serialization.py @@ -0,0 +1,1970 @@ +# -------------------------------------------------------------------------- +# +# Copyright (c) Microsoft Corporation. All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the ""Software""), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. +# +# -------------------------------------------------------------------------- + +# pylint: skip-file + +from base64 import b64decode, b64encode +import calendar +import datetime +import decimal +import email +from enum import Enum +import json +import logging +import re +import sys +import codecs + +try: + from urllib import quote # type: ignore +except ImportError: + from urllib.parse import quote # type: ignore +import xml.etree.ElementTree as ET + +import isodate + +from typing import Dict, Any, cast, TYPE_CHECKING + +from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback + +_BOM = codecs.BOM_UTF8.decode(encoding="utf-8") + +if TYPE_CHECKING: + from typing import Optional, Union, AnyStr, IO, Mapping + + +class RawDeserializer: + + # Accept "text" because we're open minded people... + JSON_REGEXP = re.compile(r"^(application|text)/([a-z+.]+\+)?json$") + + # Name used in context + CONTEXT_NAME = "deserialized_data" + + @classmethod + def deserialize_from_text(cls, data, content_type=None): + # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> Any + """Decode data according to content-type. + + Accept a stream of data as well, but will be load at once in memory for now. + + If no content-type, will return the string version (not bytes, not stream) + + :param data: Input, could be bytes or stream (will be decoded with UTF8) or text + :type data: str or bytes or IO + :param str content_type: The content type. + """ + if hasattr(data, "read"): + # Assume a stream + data = cast(IO, data).read() + + if isinstance(data, bytes): + data_as_str = data.decode(encoding="utf-8-sig") + else: + # Explain to mypy the correct type. + data_as_str = cast(str, data) + + # Remove Byte Order Mark if present in string + data_as_str = data_as_str.lstrip(_BOM) + + if content_type is None: + return data + + if cls.JSON_REGEXP.match(content_type): + try: + return json.loads(data_as_str) + except ValueError as err: + raise DeserializationError("JSON is invalid: {}".format(err), err) + elif "xml" in (content_type or []): + try: + + try: + if isinstance(data, unicode): # type: ignore + # If I'm Python 2.7 and unicode XML will scream if I try a "fromstring" on unicode string + data_as_str = data_as_str.encode(encoding="utf-8") # type: ignore + except NameError: + pass + + return ET.fromstring(data_as_str) # nosec + except ET.ParseError: + # It might be because the server has an issue, and returned JSON with + # content-type XML.... + # So let's try a JSON load, and if it's still broken + # let's flow the initial exception + def _json_attemp(data): + try: + return True, json.loads(data) + except ValueError: + return False, None # Don't care about this one + + success, json_result = _json_attemp(data) + if success: + return json_result + # If i'm here, it's not JSON, it's not XML, let's scream + # and raise the last context in this block (the XML exception) + # The function hack is because Py2.7 messes up with exception + # context otherwise. + _LOGGER.critical("Wasn't XML not JSON, failing") + raise_with_traceback(DeserializationError, "XML is invalid") + raise DeserializationError("Cannot deserialize content-type: {}".format(content_type)) + + @classmethod + def deserialize_from_http_generics(cls, body_bytes, headers): + # type: (Optional[Union[AnyStr, IO]], Mapping) -> Any + """Deserialize from HTTP response. + + Use bytes and headers to NOT use any requests/aiohttp or whatever + specific implementation. + Headers will tested for "content-type" + """ + # Try to use content-type from headers if available + content_type = None + if "content-type" in headers: + content_type = headers["content-type"].split(";")[0].strip().lower() + # Ouch, this server did not declare what it sent... + # Let's guess it's JSON... + # Also, since Autorest was considering that an empty body was a valid JSON, + # need that test as well.... + else: + content_type = "application/json" + + if body_bytes: + return cls.deserialize_from_text(body_bytes, content_type) + return None + + +try: + basestring # type: ignore + unicode_str = unicode # type: ignore +except NameError: + basestring = str # type: ignore + unicode_str = str # type: ignore + +_LOGGER = logging.getLogger(__name__) + +try: + _long_type = long # type: ignore +except NameError: + _long_type = int + + +class UTC(datetime.tzinfo): + """Time Zone info for handling UTC""" + + def utcoffset(self, dt): + """UTF offset for UTC is 0.""" + return datetime.timedelta(0) + + def tzname(self, dt): + """Timestamp representation.""" + return "Z" + + def dst(self, dt): + """No daylight saving for UTC.""" + return datetime.timedelta(hours=1) + + +try: + from datetime import timezone as _FixedOffset +except ImportError: # Python 2.7 + + class _FixedOffset(datetime.tzinfo): # type: ignore + """Fixed offset in minutes east from UTC. + Copy/pasted from Python doc + :param datetime.timedelta offset: offset in timedelta format + """ + + def __init__(self, offset): + self.__offset = offset + + def utcoffset(self, dt): + return self.__offset + + def tzname(self, dt): + return str(self.__offset.total_seconds() / 3600) + + def __repr__(self): + return "".format(self.tzname(None)) + + def dst(self, dt): + return datetime.timedelta(0) + + def __getinitargs__(self): + return (self.__offset,) + + +try: + from datetime import timezone + + TZ_UTC = timezone.utc # type: ignore +except ImportError: + TZ_UTC = UTC() # type: ignore + +_FLATTEN = re.compile(r"(? y, + "minimum": lambda x, y: x < y, + "maximum": lambda x, y: x > y, + "minimum_ex": lambda x, y: x <= y, + "maximum_ex": lambda x, y: x >= y, + "min_items": lambda x, y: len(x) < y, + "max_items": lambda x, y: len(x) > y, + "pattern": lambda x, y: not re.match(y, x, re.UNICODE), + "unique": lambda x, y: len(x) != len(set(x)), + "multiple": lambda x, y: x % y != 0, + } + + def __init__(self, classes=None): + self.serialize_type = { + "iso-8601": Serializer.serialize_iso, + "rfc-1123": Serializer.serialize_rfc, + "unix-time": Serializer.serialize_unix, + "duration": Serializer.serialize_duration, + "date": Serializer.serialize_date, + "time": Serializer.serialize_time, + "decimal": Serializer.serialize_decimal, + "long": Serializer.serialize_long, + "bytearray": Serializer.serialize_bytearray, + "base64": Serializer.serialize_base64, + "object": self.serialize_object, + "[]": self.serialize_iter, + "{}": self.serialize_dict, + } + self.dependencies = dict(classes) if classes else {} + self.key_transformer = full_restapi_key_transformer + self.client_side_validation = True + + def _serialize(self, target_obj, data_type=None, **kwargs): + """Serialize data into a string according to type. + + :param target_obj: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: str, dict + :raises: SerializationError if serialization fails. + """ + key_transformer = kwargs.get("key_transformer", self.key_transformer) + keep_readonly = kwargs.get("keep_readonly", False) + if target_obj is None: + return None + + attr_name = None + class_name = target_obj.__class__.__name__ + + if data_type: + return self.serialize_data(target_obj, data_type, **kwargs) + + if not hasattr(target_obj, "_attribute_map"): + data_type = type(target_obj).__name__ + if data_type in self.basic_types.values(): + return self.serialize_data(target_obj, data_type, **kwargs) + + # Force "is_xml" kwargs if we detect a XML model + try: + is_xml_model_serialization = kwargs["is_xml"] + except KeyError: + is_xml_model_serialization = kwargs.setdefault("is_xml", target_obj.is_xml_model()) + + serialized = {} + if is_xml_model_serialization: + serialized = target_obj._create_xml_node() + try: + attributes = target_obj._attribute_map + for attr, attr_desc in attributes.items(): + attr_name = attr + if not keep_readonly and target_obj._validation.get(attr_name, {}).get("readonly", False): + continue + + if attr_name == "additional_properties" and attr_desc["key"] == "": + if target_obj.additional_properties is not None: + serialized.update(target_obj.additional_properties) + continue + try: + + orig_attr = getattr(target_obj, attr) + if is_xml_model_serialization: + pass # Don't provide "transformer" for XML for now. Keep "orig_attr" + else: # JSON + keys, orig_attr = key_transformer(attr, attr_desc.copy(), orig_attr) + keys = keys if isinstance(keys, list) else [keys] + + kwargs["serialization_ctxt"] = attr_desc + new_attr = self.serialize_data(orig_attr, attr_desc["type"], **kwargs) + + if is_xml_model_serialization: + xml_desc = attr_desc.get("xml", {}) + xml_name = xml_desc.get("name", attr_desc["key"]) + xml_prefix = xml_desc.get("prefix", None) + xml_ns = xml_desc.get("ns", None) + if xml_desc.get("attr", False): + if xml_ns: + ET.register_namespace(xml_prefix, xml_ns) + xml_name = "{}{}".format(xml_ns, xml_name) + serialized.set(xml_name, new_attr) + continue + if xml_desc.get("text", False): + serialized.text = new_attr + continue + if isinstance(new_attr, list): + serialized.extend(new_attr) + elif isinstance(new_attr, ET.Element): + # If the down XML has no XML/Name, we MUST replace the tag with the local tag. But keeping the namespaces. + if "name" not in getattr(orig_attr, "_xml_map", {}): + splitted_tag = new_attr.tag.split("}") + if len(splitted_tag) == 2: # Namespace + new_attr.tag = "}".join([splitted_tag[0], xml_name]) + else: + new_attr.tag = xml_name + serialized.append(new_attr) + else: # That's a basic type + # Integrate namespace if necessary + local_node = _create_xml_node(xml_name, xml_prefix, xml_ns) + local_node.text = unicode_str(new_attr) + serialized.append(local_node) + else: # JSON + for k in reversed(keys): + unflattened = {k: new_attr} + new_attr = unflattened + + _new_attr = new_attr + _serialized = serialized + for k in keys: + if k not in _serialized: + _serialized.update(_new_attr) + _new_attr = _new_attr[k] + _serialized = _serialized[k] + except ValueError: + continue + + except (AttributeError, KeyError, TypeError) as err: + msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj)) + raise_with_traceback(SerializationError, msg, err) + else: + return serialized + + def body(self, data, data_type, **kwargs): + """Serialize data intended for a request body. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: dict + :raises: SerializationError if serialization fails. + :raises: ValueError if data is None + """ + + # Just in case this is a dict + internal_data_type = data_type.strip("[]{}") + internal_data_type = self.dependencies.get(internal_data_type, None) + try: + is_xml_model_serialization = kwargs["is_xml"] + except KeyError: + if internal_data_type and issubclass(internal_data_type, Model): + is_xml_model_serialization = kwargs.setdefault("is_xml", internal_data_type.is_xml_model()) + else: + is_xml_model_serialization = False + if internal_data_type and not isinstance(internal_data_type, Enum): + try: + deserializer = Deserializer(self.dependencies) + # Since it's on serialization, it's almost sure that format is not JSON REST + # We're not able to deal with additional properties for now. + deserializer.additional_properties_detection = False + if is_xml_model_serialization: + deserializer.key_extractors = [ + attribute_key_case_insensitive_extractor, + ] + else: + deserializer.key_extractors = [ + rest_key_case_insensitive_extractor, + attribute_key_case_insensitive_extractor, + last_rest_key_case_insensitive_extractor, + ] + data = deserializer._deserialize(data_type, data) + except DeserializationError as err: + raise_with_traceback(SerializationError, "Unable to build a model: " + str(err), err) + + return self._serialize(data, data_type, **kwargs) + + def url(self, name, data, data_type, **kwargs): + """Serialize data intended for a URL path. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + try: + output = self.serialize_data(data, data_type, **kwargs) + if data_type == "bool": + output = json.dumps(output) + + if kwargs.get("skip_quote") is True: + output = str(output) + else: + output = quote(str(output), safe="") + except SerializationError: + raise TypeError("{} must be type {}.".format(name, data_type)) + else: + return output + + def query(self, name, data, data_type, **kwargs): + """Serialize data intended for a URL query. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + try: + # Treat the list aside, since we don't want to encode the div separator + if data_type.startswith("["): + internal_data_type = data_type[1:-1] + data = [self.serialize_data(d, internal_data_type, **kwargs) if d is not None else "" for d in data] + if not kwargs.get("skip_quote", False): + data = [quote(str(d), safe="") for d in data] + return str(self.serialize_iter(data, internal_data_type, **kwargs)) + + # Not a list, regular serialization + output = self.serialize_data(data, data_type, **kwargs) + if data_type == "bool": + output = json.dumps(output) + if kwargs.get("skip_quote") is True: + output = str(output) + else: + output = quote(str(output), safe="") + except SerializationError: + raise TypeError("{} must be type {}.".format(name, data_type)) + else: + return str(output) + + def header(self, name, data, data_type, **kwargs): + """Serialize data intended for a request header. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :rtype: str + :raises: TypeError if serialization fails. + :raises: ValueError if data is None + """ + try: + if data_type in ["[str]"]: + data = ["" if d is None else d for d in data] + + output = self.serialize_data(data, data_type, **kwargs) + if data_type == "bool": + output = json.dumps(output) + except SerializationError: + raise TypeError("{} must be type {}.".format(name, data_type)) + else: + return str(output) + + def serialize_data(self, data, data_type, **kwargs): + """Serialize generic data according to supplied data type. + + :param data: The data to be serialized. + :param str data_type: The type to be serialized from. + :param bool required: Whether it's essential that the data not be + empty or None + :raises: AttributeError if required data is None. + :raises: ValueError if data is None + :raises: SerializationError if serialization fails. + """ + if data is None: + raise ValueError("No value for given attribute") + + try: + if data_type in self.basic_types.values(): + return self.serialize_basic(data, data_type, **kwargs) + + elif data_type in self.serialize_type: + return self.serialize_type[data_type](data, **kwargs) + + # If dependencies is empty, try with current data class + # It has to be a subclass of Enum anyway + enum_type = self.dependencies.get(data_type, data.__class__) + if issubclass(enum_type, Enum): + return Serializer.serialize_enum(data, enum_obj=enum_type) + + iter_type = data_type[0] + data_type[-1] + if iter_type in self.serialize_type: + return self.serialize_type[iter_type](data, data_type[1:-1], **kwargs) + + except (ValueError, TypeError) as err: + msg = "Unable to serialize value: {!r} as type: {!r}." + raise_with_traceback(SerializationError, msg.format(data, data_type), err) + else: + return self._serialize(data, **kwargs) + + @classmethod + def _get_custom_serializers(cls, data_type, **kwargs): + custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type) + if custom_serializer: + return custom_serializer + if kwargs.get("is_xml", False): + return cls._xml_basic_types_serializers.get(data_type) + + @classmethod + def serialize_basic(cls, data, data_type, **kwargs): + """Serialize basic builting data type. + Serializes objects to str, int, float or bool. + + Possible kwargs: + - basic_types_serializers dict[str, callable] : If set, use the callable as serializer + - is_xml bool : If set, use xml_basic_types_serializers + + :param data: Object to be serialized. + :param str data_type: Type of object in the iterable. + """ + custom_serializer = cls._get_custom_serializers(data_type, **kwargs) + if custom_serializer: + return custom_serializer(data) + if data_type == "str": + return cls.serialize_unicode(data) + return eval(data_type)(data) # nosec + + @classmethod + def serialize_unicode(cls, data): + """Special handling for serializing unicode strings in Py2. + Encode to UTF-8 if unicode, otherwise handle as a str. + + :param data: Object to be serialized. + :rtype: str + """ + try: # If I received an enum, return its value + return data.value + except AttributeError: + pass + + try: + if isinstance(data, unicode): + # Don't change it, JSON and XML ElementTree are totally able + # to serialize correctly u'' strings + return data + except NameError: + return str(data) + else: + return str(data) + + def serialize_iter(self, data, iter_type, div=None, **kwargs): + """Serialize iterable. + + Supported kwargs: + - serialization_ctxt dict : The current entry of _attribute_map, or same format. + serialization_ctxt['type'] should be same as data_type. + - is_xml bool : If set, serialize as XML + + :param list attr: Object to be serialized. + :param str iter_type: Type of object in the iterable. + :param bool required: Whether the objects in the iterable must + not be None or empty. + :param str div: If set, this str will be used to combine the elements + in the iterable into a combined string. Default is 'None'. + :rtype: list, str + """ + if isinstance(data, str): + raise SerializationError("Refuse str type as a valid iter type.") + + serialization_ctxt = kwargs.get("serialization_ctxt", {}) + is_xml = kwargs.get("is_xml", False) + + serialized = [] + for d in data: + try: + serialized.append(self.serialize_data(d, iter_type, **kwargs)) + except ValueError: + serialized.append(None) + + if div: + serialized = ["" if s is None else str(s) for s in serialized] + serialized = div.join(serialized) + + if "xml" in serialization_ctxt or is_xml: + # XML serialization is more complicated + xml_desc = serialization_ctxt.get("xml", {}) + xml_name = xml_desc.get("name") + if not xml_name: + xml_name = serialization_ctxt["key"] + + # Create a wrap node if necessary (use the fact that Element and list have "append") + is_wrapped = xml_desc.get("wrapped", False) + node_name = xml_desc.get("itemsName", xml_name) + if is_wrapped: + final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None)) + else: + final_result = [] + # All list elements to "local_node" + for el in serialized: + if isinstance(el, ET.Element): + el_node = el + else: + el_node = _create_xml_node(node_name, xml_desc.get("prefix", None), xml_desc.get("ns", None)) + if el is not None: # Otherwise it writes "None" :-p + el_node.text = str(el) + final_result.append(el_node) + return final_result + return serialized + + def serialize_dict(self, attr, dict_type, **kwargs): + """Serialize a dictionary of objects. + + :param dict attr: Object to be serialized. + :param str dict_type: Type of object in the dictionary. + :param bool required: Whether the objects in the dictionary must + not be None or empty. + :rtype: dict + """ + serialization_ctxt = kwargs.get("serialization_ctxt", {}) + serialized = {} + for key, value in attr.items(): + try: + serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs) + except ValueError: + serialized[self.serialize_unicode(key)] = None + + if "xml" in serialization_ctxt: + # XML serialization is more complicated + xml_desc = serialization_ctxt["xml"] + xml_name = xml_desc["name"] + + final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None)) + for key, value in serialized.items(): + ET.SubElement(final_result, key).text = value + return final_result + + return serialized + + def serialize_object(self, attr, **kwargs): + """Serialize a generic object. + This will be handled as a dictionary. If object passed in is not + a basic type (str, int, float, dict, list) it will simply be + cast to str. + + :param dict attr: Object to be serialized. + :rtype: dict or str + """ + if attr is None: + return None + if isinstance(attr, ET.Element): + return attr + obj_type = type(attr) + if obj_type in self.basic_types: + return self.serialize_basic(attr, self.basic_types[obj_type], **kwargs) + if obj_type is _long_type: + return self.serialize_long(attr) + if obj_type is unicode_str: + return self.serialize_unicode(attr) + if obj_type is datetime.datetime: + return self.serialize_iso(attr) + if obj_type is datetime.date: + return self.serialize_date(attr) + if obj_type is datetime.time: + return self.serialize_time(attr) + if obj_type is datetime.timedelta: + return self.serialize_duration(attr) + if obj_type is decimal.Decimal: + return self.serialize_decimal(attr) + + # If it's a model or I know this dependency, serialize as a Model + elif obj_type in self.dependencies.values() or isinstance(attr, Model): + return self._serialize(attr) + + if obj_type == dict: + serialized = {} + for key, value in attr.items(): + try: + serialized[self.serialize_unicode(key)] = self.serialize_object(value, **kwargs) + except ValueError: + serialized[self.serialize_unicode(key)] = None + return serialized + + if obj_type == list: + serialized = [] + for obj in attr: + try: + serialized.append(self.serialize_object(obj, **kwargs)) + except ValueError: + pass + return serialized + return str(attr) + + @staticmethod + def serialize_enum(attr, enum_obj=None): + try: + result = attr.value + except AttributeError: + result = attr + try: + enum_obj(result) + return result + except ValueError: + for enum_value in enum_obj: + if enum_value.value.lower() == str(attr).lower(): + return enum_value.value + error = "{!r} is not valid value for enum {!r}" + raise SerializationError(error.format(attr, enum_obj)) + + @staticmethod + def serialize_bytearray(attr, **kwargs): + """Serialize bytearray into base-64 string. + + :param attr: Object to be serialized. + :rtype: str + """ + return b64encode(attr).decode() + + @staticmethod + def serialize_base64(attr, **kwargs): + """Serialize str into base-64 string. + + :param attr: Object to be serialized. + :rtype: str + """ + encoded = b64encode(attr).decode("ascii") + return encoded.strip("=").replace("+", "-").replace("/", "_") + + @staticmethod + def serialize_decimal(attr, **kwargs): + """Serialize Decimal object to float. + + :param attr: Object to be serialized. + :rtype: float + """ + return float(attr) + + @staticmethod + def serialize_long(attr, **kwargs): + """Serialize long (Py2) or int (Py3). + + :param attr: Object to be serialized. + :rtype: int/long + """ + return _long_type(attr) + + @staticmethod + def serialize_date(attr, **kwargs): + """Serialize Date object into ISO-8601 formatted string. + + :param Date attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_date(attr) + t = "{:04}-{:02}-{:02}".format(attr.year, attr.month, attr.day) + return t + + @staticmethod + def serialize_time(attr, **kwargs): + """Serialize Time object into ISO-8601 formatted string. + + :param datetime.time attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_time(attr) + t = "{:02}:{:02}:{:02}".format(attr.hour, attr.minute, attr.second) + if attr.microsecond: + t += ".{:02}".format(attr.microsecond) + return t + + @staticmethod + def serialize_duration(attr, **kwargs): + """Serialize TimeDelta object into ISO-8601 formatted string. + + :param TimeDelta attr: Object to be serialized. + :rtype: str + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + return isodate.duration_isoformat(attr) + + @staticmethod + def serialize_rfc(attr, **kwargs): + """Serialize Datetime object into RFC-1123 formatted string. + + :param Datetime attr: Object to be serialized. + :rtype: str + :raises: TypeError if format invalid. + """ + try: + if not attr.tzinfo: + _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") + utc = attr.utctimetuple() + except AttributeError: + raise TypeError("RFC1123 object must be valid Datetime object.") + + return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format( + Serializer.days[utc.tm_wday], + utc.tm_mday, + Serializer.months[utc.tm_mon], + utc.tm_year, + utc.tm_hour, + utc.tm_min, + utc.tm_sec, + ) + + @staticmethod + def serialize_iso(attr, **kwargs): + """Serialize Datetime object into ISO-8601 formatted string. + + :param Datetime attr: Object to be serialized. + :rtype: str + :raises: SerializationError if format invalid. + """ + if isinstance(attr, str): + attr = isodate.parse_datetime(attr) + try: + if not attr.tzinfo: + _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") + utc = attr.utctimetuple() + if utc.tm_year > 9999 or utc.tm_year < 1: + raise OverflowError("Hit max or min date") + + microseconds = str(attr.microsecond).rjust(6, "0").rstrip("0").ljust(3, "0") + if microseconds: + microseconds = "." + microseconds + date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}".format( + utc.tm_year, utc.tm_mon, utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec + ) + return date + microseconds + "Z" + except (ValueError, OverflowError) as err: + msg = "Unable to serialize datetime object." + raise_with_traceback(SerializationError, msg, err) + except AttributeError as err: + msg = "ISO-8601 object must be valid Datetime object." + raise_with_traceback(TypeError, msg, err) + + @staticmethod + def serialize_unix(attr, **kwargs): + """Serialize Datetime object into IntTime format. + This is represented as seconds. + + :param Datetime attr: Object to be serialized. + :rtype: int + :raises: SerializationError if format invalid + """ + if isinstance(attr, int): + return attr + try: + if not attr.tzinfo: + _LOGGER.warning("Datetime with no tzinfo will be considered UTC.") + return int(calendar.timegm(attr.utctimetuple())) + except AttributeError: + raise TypeError("Unix time object must be valid Datetime object.") + + +def rest_key_extractor(attr, attr_desc, data): + key = attr_desc["key"] + working_data = data + + while "." in key: + dict_keys = _FLATTEN.split(key) + if len(dict_keys) == 1: + key = _decode_attribute_map_key(dict_keys[0]) + break + working_key = _decode_attribute_map_key(dict_keys[0]) + working_data = working_data.get(working_key, data) + if working_data is None: + # If at any point while following flatten JSON path see None, it means + # that all properties under are None as well + # https://github.com/Azure/msrest-for-python/issues/197 + return None + key = ".".join(dict_keys[1:]) + + return working_data.get(key) + + +def rest_key_case_insensitive_extractor(attr, attr_desc, data): + key = attr_desc["key"] + working_data = data + + while "." in key: + dict_keys = _FLATTEN.split(key) + if len(dict_keys) == 1: + key = _decode_attribute_map_key(dict_keys[0]) + break + working_key = _decode_attribute_map_key(dict_keys[0]) + working_data = attribute_key_case_insensitive_extractor(working_key, None, working_data) + if working_data is None: + # If at any point while following flatten JSON path see None, it means + # that all properties under are None as well + # https://github.com/Azure/msrest-for-python/issues/197 + return None + key = ".".join(dict_keys[1:]) + + if working_data: + return attribute_key_case_insensitive_extractor(key, None, working_data) + + +def last_rest_key_extractor(attr, attr_desc, data): + """Extract the attribute in "data" based on the last part of the JSON path key.""" + key = attr_desc["key"] + dict_keys = _FLATTEN.split(key) + return attribute_key_extractor(dict_keys[-1], None, data) + + +def last_rest_key_case_insensitive_extractor(attr, attr_desc, data): + """Extract the attribute in "data" based on the last part of the JSON path key. + + This is the case insensitive version of "last_rest_key_extractor" + """ + key = attr_desc["key"] + dict_keys = _FLATTEN.split(key) + return attribute_key_case_insensitive_extractor(dict_keys[-1], None, data) + + +def attribute_key_extractor(attr, _, data): + return data.get(attr) + + +def attribute_key_case_insensitive_extractor(attr, _, data): + found_key = None + lower_attr = attr.lower() + for key in data: + if lower_attr == key.lower(): + found_key = key + break + + return data.get(found_key) + + +def _extract_name_from_internal_type(internal_type): + """Given an internal type XML description, extract correct XML name with namespace. + + :param dict internal_type: An model type + :rtype: tuple + :returns: A tuple XML name + namespace dict + """ + internal_type_xml_map = getattr(internal_type, "_xml_map", {}) + xml_name = internal_type_xml_map.get("name", internal_type.__name__) + xml_ns = internal_type_xml_map.get("ns", None) + if xml_ns: + xml_name = "{}{}".format(xml_ns, xml_name) + return xml_name + + +def xml_key_extractor(attr, attr_desc, data): + if isinstance(data, dict): + return None + + # Test if this model is XML ready first + if not isinstance(data, ET.Element): + return None + + xml_desc = attr_desc.get("xml", {}) + xml_name = xml_desc.get("name", attr_desc["key"]) + + # Look for a children + is_iter_type = attr_desc["type"].startswith("[") + is_wrapped = xml_desc.get("wrapped", False) + internal_type = attr_desc.get("internalType", None) + internal_type_xml_map = getattr(internal_type, "_xml_map", {}) + + # Integrate namespace if necessary + xml_ns = xml_desc.get("ns", internal_type_xml_map.get("ns", None)) + if xml_ns: + xml_name = "{}{}".format(xml_ns, xml_name) + + # If it's an attribute, that's simple + if xml_desc.get("attr", False): + return data.get(xml_name) + + # If it's x-ms-text, that's simple too + if xml_desc.get("text", False): + return data.text + + # Scenario where I take the local name: + # - Wrapped node + # - Internal type is an enum (considered basic types) + # - Internal type has no XML/Name node + if is_wrapped or (internal_type and (issubclass(internal_type, Enum) or "name" not in internal_type_xml_map)): + children = data.findall(xml_name) + # If internal type has a local name and it's not a list, I use that name + elif not is_iter_type and internal_type and "name" in internal_type_xml_map: + xml_name = _extract_name_from_internal_type(internal_type) + children = data.findall(xml_name) + # That's an array + else: + if internal_type: # Complex type, ignore itemsName and use the complex type name + items_name = _extract_name_from_internal_type(internal_type) + else: + items_name = xml_desc.get("itemsName", xml_name) + children = data.findall(items_name) + + if len(children) == 0: + if is_iter_type: + if is_wrapped: + return None # is_wrapped no node, we want None + else: + return [] # not wrapped, assume empty list + return None # Assume it's not there, maybe an optional node. + + # If is_iter_type and not wrapped, return all found children + if is_iter_type: + if not is_wrapped: + return children + else: # Iter and wrapped, should have found one node only (the wrap one) + if len(children) != 1: + raise DeserializationError( + "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format( + xml_name + ) + ) + return list(children[0]) # Might be empty list and that's ok. + + # Here it's not a itertype, we should have found one element only or empty + if len(children) > 1: + raise DeserializationError("Find several XML '{}' where it was not expected".format(xml_name)) + return children[0] + + +class Deserializer(object): + """Response object model deserializer. + + :param dict classes: Class type dictionary for deserializing complex types. + :ivar list key_extractors: Ordered list of extractors to be used by this deserializer. + """ + + basic_types = {str: "str", int: "int", bool: "bool", float: "float"} + + valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?") + + def __init__(self, classes=None): + self.deserialize_type = { + "iso-8601": Deserializer.deserialize_iso, + "rfc-1123": Deserializer.deserialize_rfc, + "unix-time": Deserializer.deserialize_unix, + "duration": Deserializer.deserialize_duration, + "date": Deserializer.deserialize_date, + "time": Deserializer.deserialize_time, + "decimal": Deserializer.deserialize_decimal, + "long": Deserializer.deserialize_long, + "bytearray": Deserializer.deserialize_bytearray, + "base64": Deserializer.deserialize_base64, + "object": self.deserialize_object, + "[]": self.deserialize_iter, + "{}": self.deserialize_dict, + } + self.deserialize_expected_types = { + "duration": (isodate.Duration, datetime.timedelta), + "iso-8601": (datetime.datetime), + } + self.dependencies = dict(classes) if classes else {} + self.key_extractors = [rest_key_extractor, xml_key_extractor] + # Additional properties only works if the "rest_key_extractor" is used to + # extract the keys. Making it to work whatever the key extractor is too much + # complicated, with no real scenario for now. + # So adding a flag to disable additional properties detection. This flag should be + # used if your expect the deserialization to NOT come from a JSON REST syntax. + # Otherwise, result are unexpected + self.additional_properties_detection = True + + def __call__(self, target_obj, response_data, content_type=None): + """Call the deserializer to process a REST response. + + :param str target_obj: Target data type to deserialize to. + :param requests.Response response_data: REST response object. + :param str content_type: Swagger "produces" if available. + :raises: DeserializationError if deserialization fails. + :return: Deserialized object. + """ + data = self._unpack_content(response_data, content_type) + return self._deserialize(target_obj, data) + + def _deserialize(self, target_obj, data): + """Call the deserializer on a model. + + Data needs to be already deserialized as JSON or XML ElementTree + + :param str target_obj: Target data type to deserialize to. + :param object data: Object to deserialize. + :raises: DeserializationError if deserialization fails. + :return: Deserialized object. + """ + # This is already a model, go recursive just in case + if hasattr(data, "_attribute_map"): + constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")] + try: + for attr, mapconfig in data._attribute_map.items(): + if attr in constants: + continue + value = getattr(data, attr) + if value is None: + continue + local_type = mapconfig["type"] + internal_data_type = local_type.strip("[]{}") + if internal_data_type not in self.dependencies or isinstance(internal_data_type, Enum): + continue + setattr(data, attr, self._deserialize(local_type, value)) + return data + except AttributeError: + return + + response, class_name = self._classify_target(target_obj, data) + + if isinstance(response, basestring): + return self.deserialize_data(data, response) + elif isinstance(response, type) and issubclass(response, Enum): + return self.deserialize_enum(data, response) + + if data is None: + return data + try: + attributes = response._attribute_map + d_attrs = {} + for attr, attr_desc in attributes.items(): + # Check empty string. If it's not empty, someone has a real "additionalProperties"... + if attr == "additional_properties" and attr_desc["key"] == "": + continue + raw_value = None + # Enhance attr_desc with some dynamic data + attr_desc = attr_desc.copy() # Do a copy, do not change the real one + internal_data_type = attr_desc["type"].strip("[]{}") + if internal_data_type in self.dependencies: + attr_desc["internalType"] = self.dependencies[internal_data_type] + + for key_extractor in self.key_extractors: + found_value = key_extractor(attr, attr_desc, data) + if found_value is not None: + if raw_value is not None and raw_value != found_value: + msg = ( + "Ignoring extracted value '%s' from %s for key '%s'" + " (duplicate extraction, follow extractors order)" + ) + _LOGGER.warning(msg, found_value, key_extractor, attr) + continue + raw_value = found_value + + value = self.deserialize_data(raw_value, attr_desc["type"]) + d_attrs[attr] = value + except (AttributeError, TypeError, KeyError) as err: + msg = "Unable to deserialize to object: " + class_name + raise_with_traceback(DeserializationError, msg, err) + else: + additional_properties = self._build_additional_properties(attributes, data) + return self._instantiate_model(response, d_attrs, additional_properties) + + def _build_additional_properties(self, attribute_map, data): + if not self.additional_properties_detection: + return None + if "additional_properties" in attribute_map and attribute_map.get("additional_properties", {}).get("key") != "": + # Check empty string. If it's not empty, someone has a real "additionalProperties" + return None + if isinstance(data, ET.Element): + data = {el.tag: el.text for el in data} + + known_keys = { + _decode_attribute_map_key(_FLATTEN.split(desc["key"])[0]) + for desc in attribute_map.values() + if desc["key"] != "" + } + present_keys = set(data.keys()) + missing_keys = present_keys - known_keys + return {key: data[key] for key in missing_keys} + + def _classify_target(self, target, data): + """Check to see whether the deserialization target object can + be classified into a subclass. + Once classification has been determined, initialize object. + + :param str target: The target object type to deserialize to. + :param str/dict data: The response data to deseralize. + """ + if target is None: + return None, None + + if isinstance(target, basestring): + try: + target = self.dependencies[target] + except KeyError: + return target, target + + try: + target = target._classify(data, self.dependencies) + except AttributeError: + pass # Target is not a Model, no classify + return target, target.__class__.__name__ + + def failsafe_deserialize(self, target_obj, data, content_type=None): + """Ignores any errors encountered in deserialization, + and falls back to not deserializing the object. Recommended + for use in error deserialization, as we want to return the + HttpResponseError to users, and not have them deal with + a deserialization error. + + :param str target_obj: The target object type to deserialize to. + :param str/dict data: The response data to deseralize. + :param str content_type: Swagger "produces" if available. + """ + try: + return self(target_obj, data, content_type=content_type) + except: + _LOGGER.warning( + "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True + ) + return None + + @staticmethod + def _unpack_content(raw_data, content_type=None): + """Extract the correct structure for deserialization. + + If raw_data is a PipelineResponse, try to extract the result of RawDeserializer. + if we can't, raise. Your Pipeline should have a RawDeserializer. + + If not a pipeline response and raw_data is bytes or string, use content-type + to decode it. If no content-type, try JSON. + + If raw_data is something else, bypass all logic and return it directly. + + :param raw_data: Data to be processed. + :param content_type: How to parse if raw_data is a string/bytes. + :raises JSONDecodeError: If JSON is requested and parsing is impossible. + :raises UnicodeDecodeError: If bytes is not UTF8 + """ + # Assume this is enough to detect a Pipeline Response without importing it + context = getattr(raw_data, "context", {}) + if context: + if RawDeserializer.CONTEXT_NAME in context: + return context[RawDeserializer.CONTEXT_NAME] + raise ValueError("This pipeline didn't have the RawDeserializer policy; can't deserialize") + + # Assume this is enough to recognize universal_http.ClientResponse without importing it + if hasattr(raw_data, "body"): + return RawDeserializer.deserialize_from_http_generics(raw_data.text(), raw_data.headers) + + # Assume this enough to recognize requests.Response without importing it. + if hasattr(raw_data, "_content_consumed"): + return RawDeserializer.deserialize_from_http_generics(raw_data.text, raw_data.headers) + + if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, "read"): + return RawDeserializer.deserialize_from_text(raw_data, content_type) + return raw_data + + def _instantiate_model(self, response, attrs, additional_properties=None): + """Instantiate a response model passing in deserialized args. + + :param response: The response model class. + :param d_attrs: The deserialized response attributes. + """ + if callable(response): + subtype = getattr(response, "_subtype_map", {}) + try: + readonly = [k for k, v in response._validation.items() if v.get("readonly")] + const = [k for k, v in response._validation.items() if v.get("constant")] + kwargs = {k: v for k, v in attrs.items() if k not in subtype and k not in readonly + const} + response_obj = response(**kwargs) + for attr in readonly: + setattr(response_obj, attr, attrs.get(attr)) + if additional_properties: + response_obj.additional_properties = additional_properties + return response_obj + except TypeError as err: + msg = "Unable to deserialize {} into model {}. ".format(kwargs, response) + raise DeserializationError(msg + str(err)) + else: + try: + for attr, value in attrs.items(): + setattr(response, attr, value) + return response + except Exception as exp: + msg = "Unable to populate response model. " + msg += "Type: {}, Error: {}".format(type(response), exp) + raise DeserializationError(msg) + + def deserialize_data(self, data, data_type): + """Process data for deserialization according to data type. + + :param str data: The response string to be deserialized. + :param str data_type: The type to deserialize to. + :raises: DeserializationError if deserialization fails. + :return: Deserialized object. + """ + if data is None: + return data + + try: + if not data_type: + return data + if data_type in self.basic_types.values(): + return self.deserialize_basic(data, data_type) + if data_type in self.deserialize_type: + if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())): + return data + + is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"] + if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text: + return None + data_val = self.deserialize_type[data_type](data) + return data_val + + iter_type = data_type[0] + data_type[-1] + if iter_type in self.deserialize_type: + return self.deserialize_type[iter_type](data, data_type[1:-1]) + + obj_type = self.dependencies[data_type] + if issubclass(obj_type, Enum): + if isinstance(data, ET.Element): + data = data.text + return self.deserialize_enum(data, obj_type) + + except (ValueError, TypeError, AttributeError) as err: + msg = "Unable to deserialize response data." + msg += " Data: {}, {}".format(data, data_type) + raise_with_traceback(DeserializationError, msg, err) + else: + return self._deserialize(obj_type, data) + + def deserialize_iter(self, attr, iter_type): + """Deserialize an iterable. + + :param list attr: Iterable to be deserialized. + :param str iter_type: The type of object in the iterable. + :rtype: list + """ + if attr is None: + return None + if isinstance(attr, ET.Element): # If I receive an element here, get the children + attr = list(attr) + if not isinstance(attr, (list, set)): + raise DeserializationError("Cannot deserialize as [{}] an object of type {}".format(iter_type, type(attr))) + return [self.deserialize_data(a, iter_type) for a in attr] + + def deserialize_dict(self, attr, dict_type): + """Deserialize a dictionary. + + :param dict/list attr: Dictionary to be deserialized. Also accepts + a list of key, value pairs. + :param str dict_type: The object type of the items in the dictionary. + :rtype: dict + """ + if isinstance(attr, list): + return {x["key"]: self.deserialize_data(x["value"], dict_type) for x in attr} + + if isinstance(attr, ET.Element): + # Transform value into {"Key": "value"} + attr = {el.tag: el.text for el in attr} + return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()} + + def deserialize_object(self, attr, **kwargs): + """Deserialize a generic object. + This will be handled as a dictionary. + + :param dict attr: Dictionary to be deserialized. + :rtype: dict + :raises: TypeError if non-builtin datatype encountered. + """ + if attr is None: + return None + if isinstance(attr, ET.Element): + # Do no recurse on XML, just return the tree as-is + return attr + if isinstance(attr, basestring): + return self.deserialize_basic(attr, "str") + obj_type = type(attr) + if obj_type in self.basic_types: + return self.deserialize_basic(attr, self.basic_types[obj_type]) + if obj_type is _long_type: + return self.deserialize_long(attr) + + if obj_type == dict: + deserialized = {} + for key, value in attr.items(): + try: + deserialized[key] = self.deserialize_object(value, **kwargs) + except ValueError: + deserialized[key] = None + return deserialized + + if obj_type == list: + deserialized = [] + for obj in attr: + try: + deserialized.append(self.deserialize_object(obj, **kwargs)) + except ValueError: + pass + return deserialized + + else: + error = "Cannot deserialize generic object with type: " + raise TypeError(error + str(obj_type)) + + def deserialize_basic(self, attr, data_type): + """Deserialize basic builtin data type from string. + Will attempt to convert to str, int, float and bool. + This function will also accept '1', '0', 'true' and 'false' as + valid bool values. + + :param str attr: response string to be deserialized. + :param str data_type: deserialization data type. + :rtype: str, int, float or bool + :raises: TypeError if string format is not valid. + """ + # If we're here, data is supposed to be a basic type. + # If it's still an XML node, take the text + if isinstance(attr, ET.Element): + attr = attr.text + if not attr: + if data_type == "str": + # None or '', node is empty string. + return "" + else: + # None or '', node with a strong type is None. + # Don't try to model "empty bool" or "empty int" + return None + + if data_type == "bool": + if attr in [True, False, 1, 0]: + return bool(attr) + elif isinstance(attr, basestring): + if attr.lower() in ["true", "1"]: + return True + elif attr.lower() in ["false", "0"]: + return False + raise TypeError("Invalid boolean value: {}".format(attr)) + + if data_type == "str": + return self.deserialize_unicode(attr) + return eval(data_type)(attr) # nosec + + @staticmethod + def deserialize_unicode(data): + """Preserve unicode objects in Python 2, otherwise return data + as a string. + + :param str data: response string to be deserialized. + :rtype: str or unicode + """ + # We might be here because we have an enum modeled as string, + # and we try to deserialize a partial dict with enum inside + if isinstance(data, Enum): + return data + + # Consider this is real string + try: + if isinstance(data, unicode): + return data + except NameError: + return str(data) + else: + return str(data) + + @staticmethod + def deserialize_enum(data, enum_obj): + """Deserialize string into enum object. + + If the string is not a valid enum value it will be returned as-is + and a warning will be logged. + + :param str data: Response string to be deserialized. If this value is + None or invalid it will be returned as-is. + :param Enum enum_obj: Enum object to deserialize to. + :rtype: Enum + """ + if isinstance(data, enum_obj) or data is None: + return data + if isinstance(data, Enum): + data = data.value + if isinstance(data, int): + # Workaround. We might consider remove it in the future. + # https://github.com/Azure/azure-rest-api-specs/issues/141 + try: + return list(enum_obj.__members__.values())[data] + except IndexError: + error = "{!r} is not a valid index for enum {!r}" + raise DeserializationError(error.format(data, enum_obj)) + try: + return enum_obj(str(data)) + except ValueError: + for enum_value in enum_obj: + if enum_value.value.lower() == str(data).lower(): + return enum_value + # We don't fail anymore for unknown value, we deserialize as a string + _LOGGER.warning("Deserializer is not able to find %s as valid enum in %s", data, enum_obj) + return Deserializer.deserialize_unicode(data) + + @staticmethod + def deserialize_bytearray(attr): + """Deserialize string into bytearray. + + :param str attr: response string to be deserialized. + :rtype: bytearray + :raises: TypeError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + return bytearray(b64decode(attr)) + + @staticmethod + def deserialize_base64(attr): + """Deserialize base64 encoded string into string. + + :param str attr: response string to be deserialized. + :rtype: bytearray + :raises: TypeError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + padding = "=" * (3 - (len(attr) + 3) % 4) + attr = attr + padding + encoded = attr.replace("-", "+").replace("_", "/") + return b64decode(encoded) + + @staticmethod + def deserialize_decimal(attr): + """Deserialize string into Decimal object. + + :param str attr: response string to be deserialized. + :rtype: Decimal + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + return decimal.Decimal(attr) + except decimal.DecimalException as err: + msg = "Invalid decimal {}".format(attr) + raise_with_traceback(DeserializationError, msg, err) + + @staticmethod + def deserialize_long(attr): + """Deserialize string into long (Py2) or int (Py3). + + :param str attr: response string to be deserialized. + :rtype: long or int + :raises: ValueError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + return _long_type(attr) + + @staticmethod + def deserialize_duration(attr): + """Deserialize ISO-8601 formatted string into TimeDelta object. + + :param str attr: response string to be deserialized. + :rtype: TimeDelta + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + duration = isodate.parse_duration(attr) + except (ValueError, OverflowError, AttributeError) as err: + msg = "Cannot deserialize duration object." + raise_with_traceback(DeserializationError, msg, err) + else: + return duration + + @staticmethod + def deserialize_date(attr): + """Deserialize ISO-8601 formatted string into Date object. + + :param str attr: response string to be deserialized. + :rtype: Date + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + if re.search(r"[^\W\d_]", attr, re.I + re.U): + raise DeserializationError("Date must have only digits and -. Received: %s" % attr) + # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception. + return isodate.parse_date(attr, defaultmonth=None, defaultday=None) + + @staticmethod + def deserialize_time(attr): + """Deserialize ISO-8601 formatted string into time object. + + :param str attr: response string to be deserialized. + :rtype: datetime.time + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + if re.search(r"[^\W\d_]", attr, re.I + re.U): + raise DeserializationError("Date must have only digits and -. Received: %s" % attr) + return isodate.parse_time(attr) + + @staticmethod + def deserialize_rfc(attr): + """Deserialize RFC-1123 formatted string into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: Datetime + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + parsed_date = email.utils.parsedate_tz(attr) + date_obj = datetime.datetime( + *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60)) + ) + if not date_obj.tzinfo: + date_obj = date_obj.astimezone(tz=TZ_UTC) + except ValueError as err: + msg = "Cannot deserialize to rfc datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj + + @staticmethod + def deserialize_iso(attr): + """Deserialize ISO-8601 formatted string into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: Datetime + :raises: DeserializationError if string format invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + attr = attr.upper() + match = Deserializer.valid_date.match(attr) + if not match: + raise ValueError("Invalid datetime string: " + attr) + + check_decimal = attr.split(".") + if len(check_decimal) > 1: + decimal_str = "" + for digit in check_decimal[1]: + if digit.isdigit(): + decimal_str += digit + else: + break + if len(decimal_str) > 6: + attr = attr.replace(decimal_str, decimal_str[0:6]) + + date_obj = isodate.parse_datetime(attr) + test_utc = date_obj.utctimetuple() + if test_utc.tm_year > 9999 or test_utc.tm_year < 1: + raise OverflowError("Hit max or min date") + except (ValueError, OverflowError, AttributeError) as err: + msg = "Cannot deserialize datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj + + @staticmethod + def deserialize_unix(attr): + """Serialize Datetime object into IntTime format. + This is represented as seconds. + + :param int attr: Object to be serialized. + :rtype: Datetime + :raises: DeserializationError if format invalid + """ + if isinstance(attr, ET.Element): + attr = int(attr.text) + try: + date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC) + except ValueError as err: + msg = "Cannot deserialize to unix datetime object." + raise_with_traceback(DeserializationError, msg, err) + else: + return date_obj diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_vendor.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_vendor.py index f3ab7d777870..ca7aac216662 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_vendor.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_vendor.py @@ -14,10 +14,11 @@ if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from msrest import Deserializer, Serializer - from azure.core import PipelineClient + from ._serialization import Deserializer, Serializer + + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -25,6 +26,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -32,13 +34,13 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) + class MixinABC(ABC): """DO NOT use this class. It is for internal typing use only.""" + _client: "PipelineClient" _config: AutomationClientConfiguration _serialize: "Serializer" diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_version.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_version.py index f1fb63697cf5..e5754a47ce68 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_version.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "1.1.0b2" +VERSION = "1.0.0b1" diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/__init__.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/__init__.py index dde67942a458..103e8e40787a 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/__init__.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/__init__.py @@ -14,7 +14,8 @@ except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk -__all__ = ['AutomationClient'] + +__all__ = ["AutomationClient"] __all__.extend([p for p in _patch_all if p not in __all__]) _patch_sdk() diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_automation_client.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_automation_client.py index 9e71c6bbdaf2..2f90ca43589a 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_automation_client.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_automation_client.py @@ -9,20 +9,70 @@ from copy import deepcopy from typing import Any, Awaitable, TYPE_CHECKING -from msrest import Deserializer, Serializer - from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient from .. import models +from .._serialization import Deserializer, Serializer from ._configuration import AutomationClientConfiguration -from .operations import ActivityOperations, AgentRegistrationInformationOperations, AutomationAccountOperations, AutomationClientOperationsMixin, CertificateOperations, ConnectionOperations, ConnectionTypeOperations, CredentialOperations, DscCompilationJobOperations, DscCompilationJobStreamOperations, DscConfigurationOperations, DscNodeConfigurationOperations, DscNodeOperations, FieldsOperations, HybridRunbookWorkerGroupOperations, HybridRunbookWorkersOperations, JobOperations, JobScheduleOperations, JobStreamOperations, KeysOperations, LinkedWorkspaceOperations, ModuleOperations, NodeCountInformationOperations, NodeReportsOperations, ObjectDataTypesOperations, Operations, PrivateEndpointConnectionsOperations, PrivateLinkResourcesOperations, Python2PackageOperations, RunbookDraftOperations, RunbookOperations, ScheduleOperations, SoftwareUpdateConfigurationMachineRunsOperations, SoftwareUpdateConfigurationRunsOperations, SoftwareUpdateConfigurationsOperations, SourceControlOperations, SourceControlSyncJobOperations, SourceControlSyncJobStreamsOperations, StatisticsOperations, TestJobOperations, TestJobStreamsOperations, UsagesOperations, VariableOperations, WatcherOperations, WebhookOperations +from .operations import ( + ActivityOperations, + AgentRegistrationInformationOperations, + AutomationAccountOperations, + AutomationClientOperationsMixin, + CertificateOperations, + ConnectionOperations, + ConnectionTypeOperations, + CredentialOperations, + DeletedAutomationAccountsOperations, + DscCompilationJobOperations, + DscCompilationJobStreamOperations, + DscConfigurationOperations, + DscNodeConfigurationOperations, + DscNodeOperations, + FieldsOperations, + HybridRunbookWorkerGroupOperations, + HybridRunbookWorkersOperations, + JobOperations, + JobScheduleOperations, + JobStreamOperations, + KeysOperations, + LinkedWorkspaceOperations, + ModuleOperations, + NodeCountInformationOperations, + NodeReportsOperations, + ObjectDataTypesOperations, + Operations, + PrivateEndpointConnectionsOperations, + PrivateLinkResourcesOperations, + Python2PackageOperations, + Python3PackageOperations, + RunbookDraftOperations, + RunbookOperations, + ScheduleOperations, + SoftwareUpdateConfigurationMachineRunsOperations, + SoftwareUpdateConfigurationRunsOperations, + SoftwareUpdateConfigurationsOperations, + SourceControlOperations, + SourceControlSyncJobOperations, + SourceControlSyncJobStreamsOperations, + StatisticsOperations, + TestJobOperations, + TestJobStreamsOperations, + UsagesOperations, + VariableOperations, + WatcherOperations, + WebhookOperations, +) if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials_async import AsyncTokenCredential -class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=too-many-instance-attributes + +class AutomationClient( + AutomationClientOperationsMixin +): # pylint: disable=client-accepts-api-version-keyword,too-many-instance-attributes """Automation Client. :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations @@ -31,8 +81,6 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :ivar private_link_resources: PrivateLinkResourcesOperations operations :vartype private_link_resources: azure.mgmt.automation.aio.operations.PrivateLinkResourcesOperations - :ivar python2_package: Python2PackageOperations operations - :vartype python2_package: azure.mgmt.automation.aio.operations.Python2PackageOperations :ivar agent_registration_information: AgentRegistrationInformationOperations operations :vartype agent_registration_information: azure.mgmt.automation.aio.operations.AgentRegistrationInformationOperations @@ -40,9 +88,6 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :vartype dsc_node: azure.mgmt.automation.aio.operations.DscNodeOperations :ivar node_reports: NodeReportsOperations operations :vartype node_reports: azure.mgmt.automation.aio.operations.NodeReportsOperations - :ivar dsc_node_configuration: DscNodeConfigurationOperations operations - :vartype dsc_node_configuration: - azure.mgmt.automation.aio.operations.DscNodeConfigurationOperations :ivar dsc_compilation_job: DscCompilationJobOperations operations :vartype dsc_compilation_job: azure.mgmt.automation.aio.operations.DscCompilationJobOperations :ivar dsc_compilation_job_stream: DscCompilationJobStreamOperations operations @@ -51,14 +96,18 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :ivar node_count_information: NodeCountInformationOperations operations :vartype node_count_information: azure.mgmt.automation.aio.operations.NodeCountInformationOperations - :ivar source_control: SourceControlOperations operations - :vartype source_control: azure.mgmt.automation.aio.operations.SourceControlOperations - :ivar source_control_sync_job: SourceControlSyncJobOperations operations - :vartype source_control_sync_job: - azure.mgmt.automation.aio.operations.SourceControlSyncJobOperations - :ivar source_control_sync_job_streams: SourceControlSyncJobStreamsOperations operations - :vartype source_control_sync_job_streams: - azure.mgmt.automation.aio.operations.SourceControlSyncJobStreamsOperations + :ivar watcher: WatcherOperations operations + :vartype watcher: azure.mgmt.automation.aio.operations.WatcherOperations + :ivar software_update_configurations: SoftwareUpdateConfigurationsOperations operations + :vartype software_update_configurations: + azure.mgmt.automation.aio.operations.SoftwareUpdateConfigurationsOperations + :ivar webhook: WebhookOperations operations + :vartype webhook: azure.mgmt.automation.aio.operations.WebhookOperations + :ivar deleted_automation_accounts: DeletedAutomationAccountsOperations operations + :vartype deleted_automation_accounts: + azure.mgmt.automation.aio.operations.DeletedAutomationAccountsOperations + :ivar python3_package: Python3PackageOperations operations + :vartype python3_package: azure.mgmt.automation.aio.operations.Python3PackageOperations :ivar automation_account: AutomationAccountOperations operations :vartype automation_account: azure.mgmt.automation.aio.operations.AutomationAccountOperations :ivar statistics: StatisticsOperations operations @@ -75,9 +124,21 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :vartype connection_type: azure.mgmt.automation.aio.operations.ConnectionTypeOperations :ivar credential: CredentialOperations operations :vartype credential: azure.mgmt.automation.aio.operations.CredentialOperations + :ivar dsc_configuration: DscConfigurationOperations operations + :vartype dsc_configuration: azure.mgmt.automation.aio.operations.DscConfigurationOperations + :ivar dsc_node_configuration: DscNodeConfigurationOperations operations + :vartype dsc_node_configuration: + azure.mgmt.automation.aio.operations.DscNodeConfigurationOperations + :ivar hybrid_runbook_workers: HybridRunbookWorkersOperations operations + :vartype hybrid_runbook_workers: + azure.mgmt.automation.aio.operations.HybridRunbookWorkersOperations :ivar hybrid_runbook_worker_group: HybridRunbookWorkerGroupOperations operations :vartype hybrid_runbook_worker_group: azure.mgmt.automation.aio.operations.HybridRunbookWorkerGroupOperations + :ivar job: JobOperations operations + :vartype job: azure.mgmt.automation.aio.operations.JobOperations + :ivar job_stream: JobStreamOperations operations + :vartype job_stream: azure.mgmt.automation.aio.operations.JobStreamOperations :ivar job_schedule: JobScheduleOperations operations :vartype job_schedule: azure.mgmt.automation.aio.operations.JobScheduleOperations :ivar linked_workspace: LinkedWorkspaceOperations operations @@ -90,30 +151,10 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :vartype object_data_types: azure.mgmt.automation.aio.operations.ObjectDataTypesOperations :ivar fields: FieldsOperations operations :vartype fields: azure.mgmt.automation.aio.operations.FieldsOperations - :ivar schedule: ScheduleOperations operations - :vartype schedule: azure.mgmt.automation.aio.operations.ScheduleOperations - :ivar variable: VariableOperations operations - :vartype variable: azure.mgmt.automation.aio.operations.VariableOperations - :ivar watcher: WatcherOperations operations - :vartype watcher: azure.mgmt.automation.aio.operations.WatcherOperations - :ivar dsc_configuration: DscConfigurationOperations operations - :vartype dsc_configuration: azure.mgmt.automation.aio.operations.DscConfigurationOperations - :ivar job: JobOperations operations - :vartype job: azure.mgmt.automation.aio.operations.JobOperations - :ivar job_stream: JobStreamOperations operations - :vartype job_stream: azure.mgmt.automation.aio.operations.JobStreamOperations :ivar operations: Operations operations :vartype operations: azure.mgmt.automation.aio.operations.Operations - :ivar software_update_configurations: SoftwareUpdateConfigurationsOperations operations - :vartype software_update_configurations: - azure.mgmt.automation.aio.operations.SoftwareUpdateConfigurationsOperations - :ivar software_update_configuration_runs: SoftwareUpdateConfigurationRunsOperations operations - :vartype software_update_configuration_runs: - azure.mgmt.automation.aio.operations.SoftwareUpdateConfigurationRunsOperations - :ivar software_update_configuration_machine_runs: - SoftwareUpdateConfigurationMachineRunsOperations operations - :vartype software_update_configuration_machine_runs: - azure.mgmt.automation.aio.operations.SoftwareUpdateConfigurationMachineRunsOperations + :ivar python2_package: Python2PackageOperations operations + :vartype python2_package: azure.mgmt.automation.aio.operations.Python2PackageOperations :ivar runbook_draft: RunbookDraftOperations operations :vartype runbook_draft: azure.mgmt.automation.aio.operations.RunbookDraftOperations :ivar runbook: RunbookOperations operations @@ -122,15 +163,29 @@ class AutomationClient(AutomationClientOperationsMixin): # pylint: disable=to :vartype test_job_streams: azure.mgmt.automation.aio.operations.TestJobStreamsOperations :ivar test_job: TestJobOperations operations :vartype test_job: azure.mgmt.automation.aio.operations.TestJobOperations - :ivar webhook: WebhookOperations operations - :vartype webhook: azure.mgmt.automation.aio.operations.WebhookOperations - :ivar hybrid_runbook_workers: HybridRunbookWorkersOperations operations - :vartype hybrid_runbook_workers: - azure.mgmt.automation.aio.operations.HybridRunbookWorkersOperations - :param credential: Credential needed for the client to connect to Azure. + :ivar schedule: ScheduleOperations operations + :vartype schedule: azure.mgmt.automation.aio.operations.ScheduleOperations + :ivar software_update_configuration_machine_runs: + SoftwareUpdateConfigurationMachineRunsOperations operations + :vartype software_update_configuration_machine_runs: + azure.mgmt.automation.aio.operations.SoftwareUpdateConfigurationMachineRunsOperations + :ivar software_update_configuration_runs: SoftwareUpdateConfigurationRunsOperations operations + :vartype software_update_configuration_runs: + azure.mgmt.automation.aio.operations.SoftwareUpdateConfigurationRunsOperations + :ivar source_control: SourceControlOperations operations + :vartype source_control: azure.mgmt.automation.aio.operations.SourceControlOperations + :ivar source_control_sync_job: SourceControlSyncJobOperations operations + :vartype source_control_sync_job: + azure.mgmt.automation.aio.operations.SourceControlSyncJobOperations + :ivar source_control_sync_job_streams: SourceControlSyncJobStreamsOperations operations + :vartype source_control_sync_job_streams: + azure.mgmt.automation.aio.operations.SourceControlSyncJobStreamsOperations + :ivar variable: VariableOperations operations + :vartype variable: azure.mgmt.automation.aio.operations.VariableOperations + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: Gets subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. + subscription. The subscription ID forms part of the URI for every service call. Required. :type subscription_id: str :param base_url: Service URL. Default value is "https://management.azure.com". :type base_url: str @@ -158,21 +213,11 @@ def __init__( self.private_link_resources = PrivateLinkResourcesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.python2_package = Python2PackageOperations( - self._client, self._config, self._serialize, self._deserialize - ) self.agent_registration_information = AgentRegistrationInformationOperations( self._client, self._config, self._serialize, self._deserialize ) - self.dsc_node = DscNodeOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.node_reports = NodeReportsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.dsc_node_configuration = DscNodeConfigurationOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.dsc_node = DscNodeOperations(self._client, self._config, self._serialize, self._deserialize) + self.node_reports = NodeReportsOperations(self._client, self._config, self._serialize, self._deserialize) self.dsc_compilation_job = DscCompilationJobOperations( self._client, self._config, self._serialize, self._deserialize ) @@ -182,115 +227,72 @@ def __init__( self.node_count_information = NodeCountInformationOperations( self._client, self._config, self._serialize, self._deserialize ) - self.source_control = SourceControlOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.source_control_sync_job = SourceControlSyncJobOperations( + self.watcher = WatcherOperations(self._client, self._config, self._serialize, self._deserialize) + self.software_update_configurations = SoftwareUpdateConfigurationsOperations( self._client, self._config, self._serialize, self._deserialize ) - self.source_control_sync_job_streams = SourceControlSyncJobStreamsOperations( + self.webhook = WebhookOperations(self._client, self._config, self._serialize, self._deserialize) + self.deleted_automation_accounts = DeletedAutomationAccountsOperations( self._client, self._config, self._serialize, self._deserialize ) + self.python3_package = Python3PackageOperations(self._client, self._config, self._serialize, self._deserialize) self.automation_account = AutomationAccountOperations( self._client, self._config, self._serialize, self._deserialize ) - self.statistics = StatisticsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.usages = UsagesOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.keys = KeysOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.certificate = CertificateOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.connection = ConnectionOperations( + self.statistics = StatisticsOperations(self._client, self._config, self._serialize, self._deserialize) + self.usages = UsagesOperations(self._client, self._config, self._serialize, self._deserialize) + self.keys = KeysOperations(self._client, self._config, self._serialize, self._deserialize) + self.certificate = CertificateOperations(self._client, self._config, self._serialize, self._deserialize) + self.connection = ConnectionOperations(self._client, self._config, self._serialize, self._deserialize) + self.connection_type = ConnectionTypeOperations(self._client, self._config, self._serialize, self._deserialize) + self.credential = CredentialOperations(self._client, self._config, self._serialize, self._deserialize) + self.dsc_configuration = DscConfigurationOperations( self._client, self._config, self._serialize, self._deserialize ) - self.connection_type = ConnectionTypeOperations( + self.dsc_node_configuration = DscNodeConfigurationOperations( self._client, self._config, self._serialize, self._deserialize ) - self.credential = CredentialOperations( + self.hybrid_runbook_workers = HybridRunbookWorkersOperations( self._client, self._config, self._serialize, self._deserialize ) self.hybrid_runbook_worker_group = HybridRunbookWorkerGroupOperations( self._client, self._config, self._serialize, self._deserialize ) - self.job_schedule = JobScheduleOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.job = JobOperations(self._client, self._config, self._serialize, self._deserialize) + self.job_stream = JobStreamOperations(self._client, self._config, self._serialize, self._deserialize) + self.job_schedule = JobScheduleOperations(self._client, self._config, self._serialize, self._deserialize) self.linked_workspace = LinkedWorkspaceOperations( self._client, self._config, self._serialize, self._deserialize ) - self.activity = ActivityOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.module = ModuleOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.activity = ActivityOperations(self._client, self._config, self._serialize, self._deserialize) + self.module = ModuleOperations(self._client, self._config, self._serialize, self._deserialize) self.object_data_types = ObjectDataTypesOperations( self._client, self._config, self._serialize, self._deserialize ) - self.fields = FieldsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.schedule = ScheduleOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.variable = VariableOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.watcher = WatcherOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.dsc_configuration = DscConfigurationOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.job = JobOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.job_stream = JobStreamOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.operations = Operations( - self._client, self._config, self._serialize, self._deserialize - ) - self.software_update_configurations = SoftwareUpdateConfigurationsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.software_update_configuration_runs = SoftwareUpdateConfigurationRunsOperations( - self._client, self._config, self._serialize, self._deserialize - ) + self.fields = FieldsOperations(self._client, self._config, self._serialize, self._deserialize) + self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) + self.python2_package = Python2PackageOperations(self._client, self._config, self._serialize, self._deserialize) + self.runbook_draft = RunbookDraftOperations(self._client, self._config, self._serialize, self._deserialize) + self.runbook = RunbookOperations(self._client, self._config, self._serialize, self._deserialize) + self.test_job_streams = TestJobStreamsOperations(self._client, self._config, self._serialize, self._deserialize) + self.test_job = TestJobOperations(self._client, self._config, self._serialize, self._deserialize) + self.schedule = ScheduleOperations(self._client, self._config, self._serialize, self._deserialize) self.software_update_configuration_machine_runs = SoftwareUpdateConfigurationMachineRunsOperations( self._client, self._config, self._serialize, self._deserialize ) - self.runbook_draft = RunbookDraftOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.runbook = RunbookOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.test_job_streams = TestJobStreamsOperations( - self._client, self._config, self._serialize, self._deserialize - ) - self.test_job = TestJobOperations( + self.software_update_configuration_runs = SoftwareUpdateConfigurationRunsOperations( self._client, self._config, self._serialize, self._deserialize ) - self.webhook = WebhookOperations( + self.source_control = SourceControlOperations(self._client, self._config, self._serialize, self._deserialize) + self.source_control_sync_job = SourceControlSyncJobOperations( self._client, self._config, self._serialize, self._deserialize ) - self.hybrid_runbook_workers = HybridRunbookWorkersOperations( + self.source_control_sync_job_streams = SourceControlSyncJobStreamsOperations( self._client, self._config, self._serialize, self._deserialize ) + self.variable = VariableOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -299,7 +301,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request :param request: The network request you want to make. Required. :type request: ~azure.core.rest.HttpRequest diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_configuration.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_configuration.py index a8ad2e83bdfc..06cbd251fdb0 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_configuration.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_configuration.py @@ -25,19 +25,14 @@ class AutomationClientConfiguration(Configuration): # pylint: disable=too-many- Note that all parameters used to create this instance are saved as instance attributes. - :param credential: Credential needed for the client to connect to Azure. + :param credential: Credential needed for the client to connect to Azure. Required. :type credential: ~azure.core.credentials_async.AsyncTokenCredential :param subscription_id: Gets subscription credentials which uniquely identify Microsoft Azure - subscription. The subscription ID forms part of the URI for every service call. + subscription. The subscription ID forms part of the URI for every service call. Required. :type subscription_id: str """ - def __init__( - self, - credential: "AsyncTokenCredential", - subscription_id: str, - **kwargs: Any - ) -> None: + def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(AutomationClientConfiguration, self).__init__(**kwargs) if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -46,22 +41,21 @@ def __init__( self.credential = credential self.subscription_id = subscription_id - self.credential_scopes = kwargs.pop('credential_scopes', ['https://management.azure.com/.default']) - kwargs.setdefault('sdk_moniker', 'mgmt-automation/{}'.format(VERSION)) + self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "mgmt-automation/{}".format(VERSION)) self._configure(**kwargs) - def _configure( - self, - **kwargs: Any - ) -> None: - self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs) - self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs) - self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs) - self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs) - self.http_logging_policy = kwargs.get('http_logging_policy') or ARMHttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + def _configure(self, **kwargs: Any) -> None: + self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) + self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") if self.credential and not self.authentication_policy: - self.authentication_policy = AsyncARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs) + self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_patch.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_patch.py index 0ad201a8c586..f7dd32510333 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_patch.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_patch.py @@ -10,6 +10,7 @@ __all__: List[str] = [] # Add all objects you want publicly available to users at this package level + def patch_sdk(): """Do not remove from this file. diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_vendor.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_vendor.py index a8340cad02da..2d7c66f4e089 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_vendor.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/_vendor.py @@ -14,13 +14,14 @@ if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from msrest import Deserializer, Serializer - from azure.core import AsyncPipelineClient + from .._serialization import Deserializer, Serializer + class MixinABC(ABC): """DO NOT use this class. It is for internal typing use only.""" + _client: "AsyncPipelineClient" _config: AutomationClientConfiguration _serialize: "Serializer" diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/__init__.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/__init__.py index e8ed3f355edf..930e68918be0 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/__init__.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/__init__.py @@ -8,17 +8,17 @@ from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._python2_package_operations import Python2PackageOperations from ._agent_registration_information_operations import AgentRegistrationInformationOperations from ._dsc_node_operations import DscNodeOperations from ._node_reports_operations import NodeReportsOperations -from ._dsc_node_configuration_operations import DscNodeConfigurationOperations from ._dsc_compilation_job_operations import DscCompilationJobOperations from ._dsc_compilation_job_stream_operations import DscCompilationJobStreamOperations from ._node_count_information_operations import NodeCountInformationOperations -from ._source_control_operations import SourceControlOperations -from ._source_control_sync_job_operations import SourceControlSyncJobOperations -from ._source_control_sync_job_streams_operations import SourceControlSyncJobStreamsOperations +from ._watcher_operations import WatcherOperations +from ._software_update_configurations_operations import SoftwareUpdateConfigurationsOperations +from ._webhook_operations import WebhookOperations +from ._deleted_automation_accounts_operations import DeletedAutomationAccountsOperations +from ._python3_package_operations import Python3PackageOperations from ._automation_account_operations import AutomationAccountOperations from ._statistics_operations import StatisticsOperations from ._usages_operations import UsagesOperations @@ -27,80 +27,85 @@ from ._connection_operations import ConnectionOperations from ._connection_type_operations import ConnectionTypeOperations from ._credential_operations import CredentialOperations +from ._dsc_configuration_operations import DscConfigurationOperations +from ._dsc_node_configuration_operations import DscNodeConfigurationOperations +from ._hybrid_runbook_workers_operations import HybridRunbookWorkersOperations from ._hybrid_runbook_worker_group_operations import HybridRunbookWorkerGroupOperations +from ._job_operations import JobOperations +from ._job_stream_operations import JobStreamOperations from ._job_schedule_operations import JobScheduleOperations from ._linked_workspace_operations import LinkedWorkspaceOperations from ._activity_operations import ActivityOperations from ._module_operations import ModuleOperations from ._object_data_types_operations import ObjectDataTypesOperations from ._fields_operations import FieldsOperations -from ._schedule_operations import ScheduleOperations -from ._variable_operations import VariableOperations -from ._watcher_operations import WatcherOperations -from ._dsc_configuration_operations import DscConfigurationOperations -from ._job_operations import JobOperations -from ._job_stream_operations import JobStreamOperations from ._operations import Operations from ._automation_client_operations import AutomationClientOperationsMixin -from ._software_update_configurations_operations import SoftwareUpdateConfigurationsOperations -from ._software_update_configuration_runs_operations import SoftwareUpdateConfigurationRunsOperations -from ._software_update_configuration_machine_runs_operations import SoftwareUpdateConfigurationMachineRunsOperations +from ._python2_package_operations import Python2PackageOperations from ._runbook_draft_operations import RunbookDraftOperations from ._runbook_operations import RunbookOperations from ._test_job_streams_operations import TestJobStreamsOperations from ._test_job_operations import TestJobOperations -from ._webhook_operations import WebhookOperations -from ._hybrid_runbook_workers_operations import HybridRunbookWorkersOperations +from ._schedule_operations import ScheduleOperations +from ._software_update_configuration_machine_runs_operations import SoftwareUpdateConfigurationMachineRunsOperations +from ._software_update_configuration_runs_operations import SoftwareUpdateConfigurationRunsOperations +from ._source_control_operations import SourceControlOperations +from ._source_control_sync_job_operations import SourceControlSyncJobOperations +from ._source_control_sync_job_streams_operations import SourceControlSyncJobStreamsOperations +from ._variable_operations import VariableOperations from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'Python2PackageOperations', - 'AgentRegistrationInformationOperations', - 'DscNodeOperations', - 'NodeReportsOperations', - 'DscNodeConfigurationOperations', - 'DscCompilationJobOperations', - 'DscCompilationJobStreamOperations', - 'NodeCountInformationOperations', - 'SourceControlOperations', - 'SourceControlSyncJobOperations', - 'SourceControlSyncJobStreamsOperations', - 'AutomationAccountOperations', - 'StatisticsOperations', - 'UsagesOperations', - 'KeysOperations', - 'CertificateOperations', - 'ConnectionOperations', - 'ConnectionTypeOperations', - 'CredentialOperations', - 'HybridRunbookWorkerGroupOperations', - 'JobScheduleOperations', - 'LinkedWorkspaceOperations', - 'ActivityOperations', - 'ModuleOperations', - 'ObjectDataTypesOperations', - 'FieldsOperations', - 'ScheduleOperations', - 'VariableOperations', - 'WatcherOperations', - 'DscConfigurationOperations', - 'JobOperations', - 'JobStreamOperations', - 'Operations', - 'AutomationClientOperationsMixin', - 'SoftwareUpdateConfigurationsOperations', - 'SoftwareUpdateConfigurationRunsOperations', - 'SoftwareUpdateConfigurationMachineRunsOperations', - 'RunbookDraftOperations', - 'RunbookOperations', - 'TestJobStreamsOperations', - 'TestJobOperations', - 'WebhookOperations', - 'HybridRunbookWorkersOperations', + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "AgentRegistrationInformationOperations", + "DscNodeOperations", + "NodeReportsOperations", + "DscCompilationJobOperations", + "DscCompilationJobStreamOperations", + "NodeCountInformationOperations", + "WatcherOperations", + "SoftwareUpdateConfigurationsOperations", + "WebhookOperations", + "DeletedAutomationAccountsOperations", + "Python3PackageOperations", + "AutomationAccountOperations", + "StatisticsOperations", + "UsagesOperations", + "KeysOperations", + "CertificateOperations", + "ConnectionOperations", + "ConnectionTypeOperations", + "CredentialOperations", + "DscConfigurationOperations", + "DscNodeConfigurationOperations", + "HybridRunbookWorkersOperations", + "HybridRunbookWorkerGroupOperations", + "JobOperations", + "JobStreamOperations", + "JobScheduleOperations", + "LinkedWorkspaceOperations", + "ActivityOperations", + "ModuleOperations", + "ObjectDataTypesOperations", + "FieldsOperations", + "Operations", + "AutomationClientOperationsMixin", + "Python2PackageOperations", + "RunbookDraftOperations", + "RunbookOperations", + "TestJobStreamsOperations", + "TestJobOperations", + "ScheduleOperations", + "SoftwareUpdateConfigurationMachineRunsOperations", + "SoftwareUpdateConfigurationRunsOperations", + "SourceControlOperations", + "SourceControlSyncJobOperations", + "SourceControlSyncJobStreamsOperations", + "VariableOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_patch_sdk() diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_activity_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_activity_operations.py index a5177e26ee70..7715e892c847 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_activity_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_activity_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -22,9 +28,11 @@ from ..._vendor import _convert_request from ...operations._activity_operations import build_get_request, build_list_by_module_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ActivityOperations: """ .. warning:: @@ -44,7 +52,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get( self, @@ -56,34 +63,28 @@ async def get( ) -> _models.Activity: """Retrieve the activity in the module identified by module name and activity name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param activity_name: The name of activity. + :param activity_name: The name of activity. Required. :type activity_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Activity, or the result of cls(response) + :return: Activity or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Activity - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Activity] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Activity] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -91,7 +92,7 @@ async def get( activity_name=activity_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -99,10 +100,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -110,61 +110,51 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Activity', pipeline_response) + deserialized = self._deserialize("Activity", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities/{activityName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities/{activityName}"} # type: ignore @distributed_trace def list_by_module( - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.ActivityListResult]: + self, resource_group_name: str, automation_account_name: str, module_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Activity"]: """Retrieve a list of activities in the module identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ActivityListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.ActivityListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Activity or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Activity] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ActivityListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ActivityListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_module_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, module_name=module_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_module.metadata['url'], + template_url=self.list_by_module.metadata["url"], headers=_headers, params=_params, ) @@ -172,17 +162,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_module_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - module_name=module_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -198,10 +178,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -212,8 +190,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_module.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities"} # type: ignore + list_by_module.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_agent_registration_information_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_agent_registration_information_operations.py index cd72eb05200f..7b640612b3aa 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_agent_registration_information_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_agent_registration_information_operations.py @@ -6,9 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Optional, TypeVar - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +26,11 @@ from ..._vendor import _convert_request from ...operations._agent_registration_information_operations import build_get_request, build_regenerate_key_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class AgentRegistrationInformationOperations: """ .. warning:: @@ -42,46 +50,36 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, **kwargs: Any ) -> _models.AgentRegistration: """Retrieve the automation agent registration information. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AgentRegistration, or the result of cls(response) + :return: AgentRegistration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AgentRegistration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.AgentRegistration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.AgentRegistration] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -89,10 +87,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -100,62 +97,121 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('AgentRegistration', pipeline_response) + deserialized = self._deserialize("AgentRegistration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation"} # type: ignore - @distributed_trace_async + @overload async def regenerate_key( self, resource_group_name: str, automation_account_name: str, parameters: _models.AgentRegistrationRegenerateKeyParameter, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.AgentRegistration: """Regenerate a primary or secondary agent registration key. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param parameters: The name of the agent registration key to be regenerated. + :param parameters: The name of the agent registration key to be regenerated. Required. :type parameters: ~azure.mgmt.automation.models.AgentRegistrationRegenerateKeyParameter - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AgentRegistration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AgentRegistration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def regenerate_key( + self, + resource_group_name: str, + automation_account_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AgentRegistration: + """Regenerate a primary or secondary agent registration key. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: The name of the agent registration key to be regenerated. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AgentRegistration, or the result of cls(response) + :return: AgentRegistration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AgentRegistration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace_async + async def regenerate_key( + self, + resource_group_name: str, + automation_account_name: str, + parameters: Union[_models.AgentRegistrationRegenerateKeyParameter, IO], + **kwargs: Any + ) -> _models.AgentRegistration: + """Regenerate a primary or secondary agent registration key. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: The name of the agent registration key to be regenerated. Is either a model + type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.AgentRegistrationRegenerateKeyParameter or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AgentRegistration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AgentRegistration + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.AgentRegistration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.AgentRegistration] - _json = self._serialize.body(parameters, 'AgentRegistrationRegenerateKeyParameter') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "AgentRegistrationRegenerateKeyParameter") request = build_regenerate_key_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self.regenerate_key.metadata['url'], + content=_content, + template_url=self.regenerate_key.metadata["url"], headers=_headers, params=_params, ) @@ -163,10 +219,9 @@ async def regenerate_key( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -174,12 +229,11 @@ async def regenerate_key( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('AgentRegistration', pipeline_response) + deserialized = self._deserialize("AgentRegistration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - regenerate_key.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation/regenerateKey"} # type: ignore - + regenerate_key.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation/regenerateKey"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_automation_account_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_automation_account_operations.py index 9538380e9e9f..225044431552 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_automation_account_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_automation_account_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,20 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._automation_account_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_resource_group_request, build_list_request, build_update_request +from ...operations._automation_account_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_resource_group_request, + build_list_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class AutomationAccountOperations: """ .. warning:: @@ -44,44 +59,102 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, parameters: _models.AutomationAccountUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.AutomationAccount: """Update an automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param parameters: Parameters supplied to the update automation account. + :param parameters: Parameters supplied to the update automation account. Required. :type parameters: ~azure.mgmt.automation.models.AutomationAccountUpdateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AutomationAccount or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AutomationAccount + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AutomationAccount: + """Update an automation account. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Parameters supplied to the update automation account. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AutomationAccount or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AutomationAccount + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + parameters: Union[_models.AutomationAccountUpdateParameters, IO], + **kwargs: Any + ) -> _models.AutomationAccount: + """Update an automation account. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Parameters supplied to the update automation account. Is either a model type + or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.AutomationAccountUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AutomationAccount, or the result of cls(response) + :return: AutomationAccount or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AutomationAccount - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccount] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccount] - _json = self._serialize.body(parameters, 'AutomationAccountUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "AutomationAccountUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -90,7 +163,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -98,10 +172,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,53 +182,111 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('AutomationAccount', pipeline_response) + deserialized = self._deserialize("AutomationAccount", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, parameters: _models.AutomationAccountCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.AutomationAccount: """Create or update automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param parameters: Parameters supplied to the create or update automation account. + :param parameters: Parameters supplied to the create or update automation account. Required. :type parameters: ~azure.mgmt.automation.models.AutomationAccountCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AutomationAccount or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AutomationAccount + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AutomationAccount: + """Create or update automation account. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Parameters supplied to the create or update automation account. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AutomationAccount, or the result of cls(response) + :return: AutomationAccount or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AutomationAccount - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + parameters: Union[_models.AutomationAccountCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.AutomationAccount: + """Create or update automation account. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Parameters supplied to the create or update automation account. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.AutomationAccountCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AutomationAccount or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AutomationAccount + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccount] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccount] - _json = self._serialize.body(parameters, 'AutomationAccountCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "AutomationAccountCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -164,7 +295,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -172,10 +304,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -184,58 +315,48 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('AutomationAccount', pipeline_response) + deserialized = self._deserialize("AutomationAccount", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('AutomationAccount', pipeline_response) + deserialized = self._deserialize("AutomationAccount", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, **kwargs: Any ) -> None: """Delete an automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -243,10 +364,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -257,48 +377,38 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, **kwargs: Any ) -> _models.AutomationAccount: """Get information about an Automation Account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AutomationAccount, or the result of cls(response) + :return: AutomationAccount or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AutomationAccount - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccount] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccount] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -306,10 +416,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -317,54 +426,46 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('AutomationAccount', pipeline_response) + deserialized = self._deserialize("AutomationAccount", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore @distributed_trace def list_by_resource_group( - self, - resource_group_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.AutomationAccountListResult]: + self, resource_group_name: str, **kwargs: Any + ) -> AsyncIterable["_models.AutomationAccount"]: """Retrieve a list of accounts within a given resource group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either AutomationAccountListResult or the result of - cls(response) + :return: An iterator like instance of either AutomationAccount or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.AutomationAccountListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.AutomationAccount] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccountListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccountListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_group_request( resource_group_name=resource_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource_group.metadata['url'], + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -372,15 +473,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -396,10 +489,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -410,48 +501,38 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts"} # type: ignore @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.AutomationAccountListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.AutomationAccount"]: """Lists the Automation Accounts within an Azure subscription. Retrieve a list of accounts within a given subscription. - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either AutomationAccountListResult or the result of - cls(response) + :return: An iterator like instance of either AutomationAccount or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.AutomationAccountListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.AutomationAccount] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccountListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccountListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -459,14 +540,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -482,10 +556,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -496,8 +568,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/automationAccounts"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/automationAccounts"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_automation_client_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_automation_client_operations.py index 8f1f58997321..591a555bf94f 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_automation_client_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_automation_client_operations.py @@ -6,9 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Optional, TypeVar - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,48 +26,108 @@ from ..._vendor import _convert_request from ...operations._automation_client_operations import build_convert_graph_runbook_content_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class AutomationClientOperationsMixin(MixinABC): - @distributed_trace_async +class AutomationClientOperationsMixin(MixinABC): + @overload async def convert_graph_runbook_content( self, resource_group_name: str, automation_account_name: str, parameters: _models.GraphicalRunbookContent, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.GraphicalRunbookContent: """Post operation to serialize or deserialize GraphRunbookContent. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param parameters: Input data describing the graphical runbook. + :param parameters: Input data describing the graphical runbook. Required. :type parameters: ~azure.mgmt.automation.models.GraphicalRunbookContent - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: GraphicalRunbookContent or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.GraphicalRunbookContent + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def convert_graph_runbook_content( + self, + resource_group_name: str, + automation_account_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.GraphicalRunbookContent: + """Post operation to serialize or deserialize GraphRunbookContent. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Input data describing the graphical runbook. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: GraphicalRunbookContent or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.GraphicalRunbookContent + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def convert_graph_runbook_content( + self, + resource_group_name: str, + automation_account_name: str, + parameters: Union[_models.GraphicalRunbookContent, IO], + **kwargs: Any + ) -> _models.GraphicalRunbookContent: + """Post operation to serialize or deserialize GraphRunbookContent. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Input data describing the graphical runbook. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.GraphicalRunbookContent or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: GraphicalRunbookContent, or the result of cls(response) + :return: GraphicalRunbookContent or the result of cls(response) :rtype: ~azure.mgmt.automation.models.GraphicalRunbookContent - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.GraphicalRunbookContent] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.GraphicalRunbookContent] - _json = self._serialize.body(parameters, 'GraphicalRunbookContent') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "GraphicalRunbookContent") request = build_convert_graph_runbook_content_request( resource_group_name=resource_group_name, @@ -70,7 +136,8 @@ async def convert_graph_runbook_content( api_version=api_version, content_type=content_type, json=_json, - template_url=self.convert_graph_runbook_content.metadata['url'], + content=_content, + template_url=self.convert_graph_runbook_content.metadata["url"], headers=_headers, params=_params, ) @@ -78,10 +145,9 @@ async def convert_graph_runbook_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -89,12 +155,11 @@ async def convert_graph_runbook_content( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('GraphicalRunbookContent', pipeline_response) + deserialized = self._deserialize("GraphicalRunbookContent", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - convert_graph_runbook_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/convertGraphRunbookContent"} # type: ignore - + convert_graph_runbook_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/convertGraphRunbookContent"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_certificate_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_certificate_operations.py index 6d78b4cef7aa..7be442c195cf 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_certificate_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_certificate_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._certificate_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._certificate_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class CertificateOperations: """ .. warning:: @@ -44,50 +58,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - certificate_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, certificate_name: str, **kwargs: Any ) -> None: """Delete the certificate. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param certificate_name: The name of certificate. + :param certificate_name: The name of certificate. Required. :type certificate_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, certificate_name=certificate_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +98,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,52 +111,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - certificate_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, certificate_name: str, **kwargs: Any ) -> _models.Certificate: """Retrieve the certificate identified by certificate name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param certificate_name: The name of certificate. + :param certificate_name: The name of certificate. Required. :type certificate_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Certificate, or the result of cls(response) + :return: Certificate or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Certificate - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Certificate] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Certificate] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, certificate_name=certificate_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +153,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,56 +163,125 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Certificate', pipeline_response) + deserialized = self._deserialize("Certificate", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, certificate_name: str, parameters: _models.CertificateCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Certificate: """Create a certificate. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param certificate_name: The parameters supplied to the create or update certificate operation. + Required. :type certificate_name: str :param parameters: The parameters supplied to the create or update certificate operation. + Required. :type parameters: ~azure.mgmt.automation.models.CertificateCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Certificate or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Certificate + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + certificate_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Certificate: + """Create a certificate. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param certificate_name: The parameters supplied to the create or update certificate operation. + Required. + :type certificate_name: str + :param parameters: The parameters supplied to the create or update certificate operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Certificate or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Certificate + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + certificate_name: str, + parameters: Union[_models.CertificateCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Certificate: + """Create a certificate. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param certificate_name: The parameters supplied to the create or update certificate operation. + Required. + :type certificate_name: str + :param parameters: The parameters supplied to the create or update certificate operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.CertificateCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Certificate, or the result of cls(response) + :return: Certificate or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Certificate - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Certificate] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Certificate] - _json = self._serialize.body(parameters, 'CertificateCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "CertificateCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -232,7 +291,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -240,10 +300,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -252,59 +311,123 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Certificate', pipeline_response) + deserialized = self._deserialize("Certificate", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Certificate', pipeline_response) + deserialized = self._deserialize("Certificate", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, certificate_name: str, parameters: _models.CertificateUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Certificate: """Update a certificate. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param certificate_name: The parameters supplied to the update certificate operation. + :param certificate_name: The parameters supplied to the update certificate operation. Required. :type certificate_name: str - :param parameters: The parameters supplied to the update certificate operation. + :param parameters: The parameters supplied to the update certificate operation. Required. :type parameters: ~azure.mgmt.automation.models.CertificateUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Certificate, or the result of cls(response) + :return: Certificate or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Certificate - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + certificate_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Certificate: + """Update a certificate. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param certificate_name: The parameters supplied to the update certificate operation. Required. + :type certificate_name: str + :param parameters: The parameters supplied to the update certificate operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Certificate or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Certificate + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + certificate_name: str, + parameters: Union[_models.CertificateUpdateParameters, IO], + **kwargs: Any + ) -> _models.Certificate: + """Update a certificate. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param certificate_name: The parameters supplied to the update certificate operation. Required. + :type certificate_name: str + :param parameters: The parameters supplied to the update certificate operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.CertificateUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Certificate or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Certificate + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Certificate] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Certificate] - _json = self._serialize.body(parameters, 'CertificateUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "CertificateUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -314,7 +437,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -322,10 +446,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -333,58 +456,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Certificate', pipeline_response) + deserialized = self._deserialize("Certificate", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.CertificateListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Certificate"]: """Retrieve a list of certificates. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either CertificateListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.CertificateListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Certificate or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Certificate] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.CertificateListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.CertificateListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -392,16 +505,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -417,10 +521,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -431,8 +533,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_connection_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_connection_operations.py index d68cac2b2094..1fb9b5fdc370 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_connection_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_connection_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._connection_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._connection_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ConnectionOperations: """ .. warning:: @@ -44,50 +58,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - connection_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, connection_name: str, **kwargs: Any ) -> None: """Delete the connection. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_name: The name of connection. + :param connection_name: The name of connection. Required. :type connection_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, connection_name=connection_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +98,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -109,52 +111,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - connection_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, connection_name: str, **kwargs: Any ) -> _models.Connection: """Retrieve the connection identified by connection name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_name: The name of connection. + :param connection_name: The name of connection. Required. :type connection_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Connection, or the result of cls(response) + :return: Connection or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Connection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Connection] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Connection] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, connection_name=connection_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +153,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,56 +163,125 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Connection', pipeline_response) + deserialized = self._deserialize("Connection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, connection_name: str, parameters: _models.ConnectionCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Connection: """Create or update a connection. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param connection_name: The parameters supplied to the create or update connection operation. + Required. :type connection_name: str :param parameters: The parameters supplied to the create or update connection operation. + Required. :type parameters: ~azure.mgmt.automation.models.ConnectionCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Connection or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Connection + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + connection_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Connection: + """Create or update a connection. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_name: The parameters supplied to the create or update connection operation. + Required. + :type connection_name: str + :param parameters: The parameters supplied to the create or update connection operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Connection or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Connection + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + connection_name: str, + parameters: Union[_models.ConnectionCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Connection: + """Create or update a connection. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_name: The parameters supplied to the create or update connection operation. + Required. + :type connection_name: str + :param parameters: The parameters supplied to the create or update connection operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ConnectionCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Connection, or the result of cls(response) + :return: Connection or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Connection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Connection] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Connection] - _json = self._serialize.body(parameters, 'ConnectionCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ConnectionCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -232,7 +291,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -240,10 +300,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -252,59 +311,123 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Connection', pipeline_response) + deserialized = self._deserialize("Connection", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Connection', pipeline_response) + deserialized = self._deserialize("Connection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, connection_name: str, parameters: _models.ConnectionUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Connection: """Update a connection. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_name: The parameters supplied to the update a connection operation. + :param connection_name: The parameters supplied to the update a connection operation. Required. :type connection_name: str - :param parameters: The parameters supplied to the update a connection operation. + :param parameters: The parameters supplied to the update a connection operation. Required. :type parameters: ~azure.mgmt.automation.models.ConnectionUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Connection, or the result of cls(response) + :return: Connection or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Connection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + connection_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Connection: + """Update a connection. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_name: The parameters supplied to the update a connection operation. Required. + :type connection_name: str + :param parameters: The parameters supplied to the update a connection operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Connection or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Connection + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + connection_name: str, + parameters: Union[_models.ConnectionUpdateParameters, IO], + **kwargs: Any + ) -> _models.Connection: + """Update a connection. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_name: The parameters supplied to the update a connection operation. Required. + :type connection_name: str + :param parameters: The parameters supplied to the update a connection operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ConnectionUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Connection or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Connection + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Connection] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Connection] - _json = self._serialize.body(parameters, 'ConnectionUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ConnectionUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -314,7 +437,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -322,10 +446,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -333,58 +456,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Connection', pipeline_response) + deserialized = self._deserialize("Connection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.ConnectionListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Connection"]: """Retrieve a list of connections. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ConnectionListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.ConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Connection or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Connection] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -392,16 +505,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -417,10 +521,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -431,8 +533,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_connection_type_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_connection_type_operations.py index b8524a869b54..e0163a1221f4 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_connection_type_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_connection_type_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,18 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._connection_type_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request +from ...operations._connection_type_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ConnectionTypeOperations: """ .. warning:: @@ -44,50 +57,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - connection_type_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, connection_type_name: str, **kwargs: Any ) -> None: """Delete the connection type. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_type_name: The name of connection type. + :param connection_type_name: The name of connection type. Required. :type connection_type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, connection_type_name=connection_type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +97,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -109,52 +110,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - connection_type_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, connection_type_name: str, **kwargs: Any ) -> _models.ConnectionType: """Retrieve the connection type identified by connection type name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_type_name: The name of connection type. + :param connection_type_name: The name of connection type. Required. :type connection_type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ConnectionType, or the result of cls(response) + :return: ConnectionType or the result of cls(response) :rtype: ~azure.mgmt.automation.models.ConnectionType - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ConnectionType] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionType] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, connection_type_name=connection_type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +152,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,57 +162,125 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ConnectionType', pipeline_response) + deserialized = self._deserialize("ConnectionType", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, connection_type_name: str, parameters: _models.ConnectionTypeCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.ConnectionType: """Create a connection type. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param connection_type_name: The parameters supplied to the create or update connection type - operation. + operation. Required. :type connection_type_name: str :param parameters: The parameters supplied to the create or update connection type operation. + Required. :type parameters: ~azure.mgmt.automation.models.ConnectionTypeCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: ConnectionType or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.ConnectionType + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + connection_type_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConnectionType: + """Create a connection type. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_type_name: The parameters supplied to the create or update connection type + operation. Required. + :type connection_type_name: str + :param parameters: The parameters supplied to the create or update connection type operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ConnectionType, or the result of cls(response) + :return: ConnectionType or the result of cls(response) :rtype: ~azure.mgmt.automation.models.ConnectionType - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + connection_type_name: str, + parameters: Union[_models.ConnectionTypeCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.ConnectionType: + """Create a connection type. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_type_name: The parameters supplied to the create or update connection type + operation. Required. + :type connection_type_name: str + :param parameters: The parameters supplied to the create or update connection type operation. + Is either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ConnectionTypeCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: ConnectionType or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.ConnectionType + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ConnectionType] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionType] - _json = self._serialize.body(parameters, 'ConnectionTypeCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ConnectionTypeCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -233,7 +290,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -241,10 +299,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -252,58 +309,48 @@ async def create_or_update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ConnectionType', pipeline_response) + deserialized = self._deserialize("ConnectionType", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.ConnectionTypeListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.ConnectionType"]: """Retrieve a list of connection types. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ConnectionTypeListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.ConnectionTypeListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ConnectionType or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.ConnectionType] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ConnectionTypeListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionTypeListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -311,16 +358,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -336,10 +374,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -350,8 +386,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_credential_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_credential_operations.py index f27e9a1d29ed..d70c0f16c8bc 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_credential_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_credential_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._credential_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._credential_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class CredentialOperations: """ .. warning:: @@ -44,50 +58,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - credential_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, credential_name: str, **kwargs: Any ) -> None: """Delete the credential. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param credential_name: The name of credential. + :param credential_name: The name of credential. Required. :type credential_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, credential_name=credential_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +98,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,52 +111,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - credential_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, credential_name: str, **kwargs: Any ) -> _models.Credential: """Retrieve the credential identified by credential name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param credential_name: The name of credential. + :param credential_name: The name of credential. Required. :type credential_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Credential, or the result of cls(response) + :return: Credential or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Credential - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Credential] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Credential] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, credential_name=credential_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +153,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,56 +163,125 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Credential', pipeline_response) + deserialized = self._deserialize("Credential", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, credential_name: str, parameters: _models.CredentialCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Credential: """Create a credential. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param credential_name: The parameters supplied to the create or update credential operation. + Required. :type credential_name: str :param parameters: The parameters supplied to the create or update credential operation. + Required. :type parameters: ~azure.mgmt.automation.models.CredentialCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Credential or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Credential + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + credential_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Credential: + """Create a credential. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param credential_name: The parameters supplied to the create or update credential operation. + Required. + :type credential_name: str + :param parameters: The parameters supplied to the create or update credential operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Credential or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Credential + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + credential_name: str, + parameters: Union[_models.CredentialCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Credential: + """Create a credential. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param credential_name: The parameters supplied to the create or update credential operation. + Required. + :type credential_name: str + :param parameters: The parameters supplied to the create or update credential operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.CredentialCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Credential, or the result of cls(response) + :return: Credential or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Credential - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Credential] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Credential] - _json = self._serialize.body(parameters, 'CredentialCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "CredentialCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -232,7 +291,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -240,10 +300,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -252,59 +311,123 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Credential', pipeline_response) + deserialized = self._deserialize("Credential", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Credential', pipeline_response) + deserialized = self._deserialize("Credential", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, credential_name: str, parameters: _models.CredentialUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Credential: """Update a credential. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param credential_name: The parameters supplied to the Update credential operation. + :param credential_name: The parameters supplied to the Update credential operation. Required. :type credential_name: str - :param parameters: The parameters supplied to the Update credential operation. + :param parameters: The parameters supplied to the Update credential operation. Required. :type parameters: ~azure.mgmt.automation.models.CredentialUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Credential, or the result of cls(response) + :return: Credential or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Credential - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + credential_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Credential: + """Update a credential. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param credential_name: The parameters supplied to the Update credential operation. Required. + :type credential_name: str + :param parameters: The parameters supplied to the Update credential operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Credential or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Credential + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + credential_name: str, + parameters: Union[_models.CredentialUpdateParameters, IO], + **kwargs: Any + ) -> _models.Credential: + """Update a credential. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param credential_name: The parameters supplied to the Update credential operation. Required. + :type credential_name: str + :param parameters: The parameters supplied to the Update credential operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.CredentialUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Credential or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Credential + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Credential] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Credential] - _json = self._serialize.body(parameters, 'CredentialUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "CredentialUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -314,7 +437,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -322,10 +446,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -333,58 +456,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Credential', pipeline_response) + deserialized = self._deserialize("Credential", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.CredentialListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Credential"]: """Retrieve a list of credentials. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either CredentialListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.CredentialListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Credential or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Credential] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.CredentialListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.CredentialListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -392,16 +505,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -417,10 +521,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -430,8 +532,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_deleted_automation_accounts_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_deleted_automation_accounts_operations.py new file mode 100644 index 000000000000..ffc7bda2670a --- /dev/null +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_deleted_automation_accounts_operations.py @@ -0,0 +1,99 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from typing import Any, Callable, Dict, Optional, TypeVar + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.pipeline.transport import AsyncHttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from ... import models as _models +from ..._vendor import _convert_request +from ...operations._deleted_automation_accounts_operations import build_list_by_subscription_request +from .._vendor import MixinABC + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class DeletedAutomationAccountsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.automation.aio.AutomationClient`'s + :attr:`deleted_automation_accounts` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + async def list_by_subscription(self, **kwargs: Any) -> _models.DeletedAutomationAccountListResult: + """Retrieve deleted automation account. + + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DeletedAutomationAccountListResult or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DeletedAutomationAccountListResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedAutomationAccountListResult] + + request = build_list_by_subscription_request( + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("DeletedAutomationAccountListResult", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/deletedAutomationAccounts"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_compilation_job_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_compilation_job_operations.py index 189cba2eedd2..aeb2cf24692b 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_compilation_job_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_compilation_job_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,11 +28,18 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._dsc_compilation_job_operations import build_create_request_initial, build_get_request, build_get_stream_request, build_list_by_automation_account_request +from ...operations._dsc_compilation_job_operations import ( + build_create_request, + build_get_request, + build_get_stream_request, + build_list_by_automation_account_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class DscCompilationJobOperations: """ .. warning:: @@ -46,30 +59,33 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - async def _create_initial( self, resource_group_name: str, automation_account_name: str, compilation_job_name: str, - parameters: _models.DscCompilationJobCreateParameters, + parameters: Union[_models.DscCompilationJobCreateParameters, IO], **kwargs: Any ) -> _models.DscCompilationJob: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscCompilationJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscCompilationJob] - _json = self._serialize.body(parameters, 'DscCompilationJobCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "DscCompilationJobCreateParameters") - request = build_create_request_initial( + request = build_create_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, compilation_job_name=compilation_job_name, @@ -77,7 +93,8 @@ async def _create_initial( api_version=api_version, content_type=content_type, json=_json, - template_url=self._create_initial.metadata['url'], + content=_content, + template_url=self._create_initial.metadata["url"], headers=_headers, params=_params, ) @@ -85,48 +102,124 @@ async def _create_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscCompilationJob', pipeline_response) + deserialized = self._deserialize("DscCompilationJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore - + _create_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore - @distributed_trace_async + @overload async def begin_create( self, resource_group_name: str, automation_account_name: str, compilation_job_name: str, parameters: _models.DscCompilationJobCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> AsyncLROPoller[_models.DscCompilationJob]: """Creates the Dsc compilation job of the configuration. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param compilation_job_name: The DSC configuration Id. + :param compilation_job_name: The DSC configuration Id. Required. :type compilation_job_name: str - :param parameters: The parameters supplied to the create compilation job operation. + :param parameters: The parameters supplied to the create compilation job operation. Required. :type parameters: ~azure.mgmt.automation.models.DscCompilationJobCreateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either DscCompilationJob or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.DscCompilationJob] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_create( + self, + resource_group_name: str, + automation_account_name: str, + compilation_job_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[_models.DscCompilationJob]: + """Creates the Dsc compilation job of the configuration. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param compilation_job_name: The DSC configuration Id. Required. + :type compilation_job_name: str + :param parameters: The parameters supplied to the create compilation job operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either DscCompilationJob or the result of + cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.DscCompilationJob] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_create( + self, + resource_group_name: str, + automation_account_name: str, + compilation_job_name: str, + parameters: Union[_models.DscCompilationJobCreateParameters, IO], + **kwargs: Any + ) -> AsyncLROPoller[_models.DscCompilationJob]: + """Creates the Dsc compilation job of the configuration. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param compilation_job_name: The DSC configuration Id. Required. + :type compilation_job_name: str + :param parameters: The parameters supplied to the create compilation job operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.DscCompilationJobCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -138,20 +231,17 @@ async def begin_create( :return: An instance of AsyncLROPoller that returns either DscCompilationJob or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.DscCompilationJob] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscCompilationJob] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscCompilationJob] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_initial( # type: ignore resource_group_name=resource_group_name, @@ -160,83 +250,69 @@ async def begin_create( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('DscCompilationJob', pipeline_response) + deserialized = self._deserialize("DscCompilationJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore + begin_create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - compilation_job_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, compilation_job_name: str, **kwargs: Any ) -> _models.DscCompilationJob: """Retrieve the Dsc configuration compilation job identified by job id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param compilation_job_name: The DSC configuration Id. + :param compilation_job_name: The DSC configuration Id. Required. :type compilation_job_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscCompilationJob, or the result of cls(response) + :return: DscCompilationJob or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscCompilationJob - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscCompilationJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscCompilationJob] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, compilation_job_name=compilation_job_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -244,10 +320,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -255,62 +330,52 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscCompilationJob', pipeline_response) + deserialized = self._deserialize("DscCompilationJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> AsyncIterable[_models.DscCompilationJobListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.DscCompilationJob"]: """Retrieve a list of dsc compilation jobs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscCompilationJobListResult or the result of - cls(response) + :return: An iterator like instance of either DscCompilationJob or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscCompilationJobListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscCompilationJob] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscCompilationJobListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscCompilationJobListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -318,17 +383,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -344,10 +399,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -358,51 +411,38 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs"} # type: ignore @distributed_trace_async async def get_stream( - self, - resource_group_name: str, - automation_account_name: str, - job_id: str, - job_stream_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, job_id: str, job_stream_id: str, **kwargs: Any ) -> _models.JobStream: """Retrieve the job stream identified by job stream id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_id: The job id. + :param job_id: The job id. Required. :type job_id: str - :param job_stream_id: The job stream id. + :param job_stream_id: The job stream id. Required. :type job_stream_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobStream, or the result of cls(response) + :return: JobStream or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobStream - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStream] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStream] - request = build_get_stream_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -410,7 +450,7 @@ async def get_stream( job_stream_id=job_stream_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_stream.metadata['url'], + template_url=self.get_stream.metadata["url"], headers=_headers, params=_params, ) @@ -418,10 +458,9 @@ async def get_stream( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -429,12 +468,11 @@ async def get_stream( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobStream', pipeline_response) + deserialized = self._deserialize("JobStream", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_stream.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams/{jobStreamId}"} # type: ignore - + get_stream.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams/{jobStreamId}"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_compilation_job_stream_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_compilation_job_stream_operations.py index c4e8bd85ce34..e6540c024f9e 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_compilation_job_stream_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_compilation_job_stream_operations.py @@ -8,7 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +26,11 @@ from ..._vendor import _convert_request from ...operations._dsc_compilation_job_stream_operations import build_list_by_job_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class DscCompilationJobStreamOperations: """ .. warning:: @@ -42,50 +50,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def list_by_job( - self, - resource_group_name: str, - automation_account_name: str, - job_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, job_id: str, **kwargs: Any ) -> _models.JobStreamListResult: """Retrieve all the job streams for the compilation Job. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_id: The job id. + :param job_id: The job id. Required. :type job_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobStreamListResult, or the result of cls(response) + :return: JobStreamListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobStreamListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStreamListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStreamListResult] - request = build_list_by_job_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_id=job_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_job.metadata['url'], + template_url=self.list_by_job.metadata["url"], headers=_headers, params=_params, ) @@ -93,10 +90,9 @@ async def list_by_job( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -104,12 +100,11 @@ async def list_by_job( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobStreamListResult', pipeline_response) + deserialized = self._deserialize("JobStreamListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_job.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams"} # type: ignore - + list_by_job.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_configuration_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_configuration_operations.py index c2204638d83e..09e34f5a2567 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_configuration_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_configuration_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar, Union +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,20 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._dsc_configuration_operations import build_create_or_update_request, build_delete_request, build_get_content_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._dsc_configuration_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_content_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class DscConfigurationOperations: """ .. warning:: @@ -44,50 +59,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, configuration_name: str, **kwargs: Any ) -> None: """Delete the dsc configuration identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The configuration name. + :param configuration_name: The configuration name. Required. :type configuration_name: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, configuration_name=configuration_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +99,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -109,52 +112,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, configuration_name: str, **kwargs: Any ) -> _models.DscConfiguration: """Retrieve the configuration identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The configuration name. + :param configuration_name: The configuration name. Required. :type configuration_name: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscConfiguration, or the result of cls(response) + :return: DscConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscConfiguration] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, configuration_name=configuration_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +154,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,71 +164,120 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscConfiguration', pipeline_response) + deserialized = self._deserialize("DscConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + configuration_name: str, + parameters: _models.DscConfigurationCreateOrUpdateParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.DscConfiguration: + """Create the configuration identified by configuration name. - @distributed_trace_async + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param configuration_name: The create or update parameters for configuration. Required. + :type configuration_name: str + :param parameters: The create or update parameters for configuration. Required. + :type parameters: ~azure.mgmt.automation.models.DscConfigurationCreateOrUpdateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, configuration_name: str, - parameters: Union[str, _models.DscConfigurationCreateOrUpdateParameters], + parameters: str, *, - content_type: Optional[str] = "application/json", + content_type: Optional[str] = None, **kwargs: Any ) -> _models.DscConfiguration: """Create the configuration identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The create or update parameters for configuration. + :param configuration_name: The create or update parameters for configuration. Required. :type configuration_name: str - :param parameters: The create or update parameters for configuration. - :type parameters: str or ~azure.mgmt.automation.models.DscConfigurationCreateOrUpdateParameters - :keyword content_type: Media type of the body sent to the API. Known values are: "text/plain; - charset=utf-8" or "application/json". Default value is "application/json". + :param parameters: The create or update parameters for configuration. Required. + :type parameters: str + :keyword content_type: Body Parameter content-type. Content type parameter for string body. + Default value is None. :paramtype content_type: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscConfiguration, or the result of cls(response) + :return: DscConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) - _headers = kwargs.pop("headers", {}) or {} + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + configuration_name: str, + parameters: Union[_models.DscConfigurationCreateOrUpdateParameters, str], + **kwargs: Any + ) -> _models.DscConfiguration: + """Create the configuration identified by configuration name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param configuration_name: The create or update parameters for configuration. Required. + :type configuration_name: str + :param parameters: The create or update parameters for configuration. Is either a model type or + a string type. Required. + :type parameters: ~azure.mgmt.automation.models.DscConfigurationCreateOrUpdateParameters or str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json', + 'text/plain; charset=utf-8'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscConfiguration] _json = None _content = None - content_type = content_type or "" - if content_type.split(";")[0] in ['application/json']: - _json = parameters - elif content_type.split(";")[0] in ['text/plain']: - _content = parameters - else: - raise ValueError( - "The content_type '{}' is not one of the allowed values: " - "['text/plain; charset=utf-8', 'application/json']".format(content_type) - ) + if isinstance(parameters, msrest.Model): + content_type = content_type or "application/json" + _json = self._serialize.body(parameters, "DscConfigurationCreateOrUpdateParameters") + elif isinstance(parameters, str): + _content = self._serialize.body(parameters, "str") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -248,7 +288,7 @@ async def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata['url'], + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -256,10 +296,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -268,74 +307,129 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('DscConfiguration', pipeline_response) + deserialized = self._deserialize("DscConfiguration", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('DscConfiguration', pipeline_response) + deserialized = self._deserialize("DscConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + configuration_name: str, + parameters: Optional[_models.DscConfigurationUpdateParameters] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.DscConfiguration: + """Create the configuration identified by configuration name. + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param configuration_name: The create or update parameters for configuration. Required. + :type configuration_name: str + :param parameters: The create or update parameters for configuration. Default value is None. + :type parameters: ~azure.mgmt.automation.models.DscConfigurationUpdateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, configuration_name: str, - parameters: Optional[Union[str, _models.DscConfigurationUpdateParameters]] = None, + parameters: Optional[str] = None, *, - content_type: Optional[str] = "application/json", + content_type: Optional[str] = None, **kwargs: Any ) -> _models.DscConfiguration: """Create the configuration identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The create or update parameters for configuration. + :param configuration_name: The create or update parameters for configuration. Required. :type configuration_name: str :param parameters: The create or update parameters for configuration. Default value is None. - :type parameters: str or ~azure.mgmt.automation.models.DscConfigurationUpdateParameters - :keyword content_type: Media type of the body sent to the API. Known values are: "text/plain; - charset=utf-8" or "application/json". Default value is "application/json". + :type parameters: str + :keyword content_type: Body Parameter content-type. Content type parameter for string body. + Default value is None. :paramtype content_type: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscConfiguration, or the result of cls(response) + :return: DscConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) - _headers = kwargs.pop("headers", {}) or {} + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + configuration_name: str, + parameters: Optional[Union[_models.DscConfigurationUpdateParameters, str]] = None, + **kwargs: Any + ) -> _models.DscConfiguration: + """Create the configuration identified by configuration name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param configuration_name: The create or update parameters for configuration. Required. + :type configuration_name: str + :param parameters: The create or update parameters for configuration. Is either a model type or + a string type. Default value is None. + :type parameters: ~azure.mgmt.automation.models.DscConfigurationUpdateParameters or str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json', + 'text/plain; charset=utf-8'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscConfiguration] _json = None _content = None - content_type = content_type or "" - if content_type.split(";")[0] in ['application/json']: - _json = parameters - elif content_type.split(";")[0] in ['text/plain']: - _content = parameters - else: - raise ValueError( - "The content_type '{}' is not one of the allowed values: " - "['text/plain; charset=utf-8', 'application/json']".format(content_type) - ) + if isinstance(parameters, msrest.Model): + content_type = content_type or "application/json" + if parameters is not None: + _json = self._serialize.body(parameters, "DscConfigurationUpdateParameters") + else: + _json = None + elif isinstance(parameters, str): + if parameters is not None: + _content = self._serialize.body(parameters, "str") + else: + _content = None request = build_update_request( resource_group_name=resource_group_name, @@ -346,7 +440,7 @@ async def update( content_type=content_type, json=_json, content=_content, - template_url=self.update.metadata['url'], + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -354,10 +448,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -365,59 +458,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscConfiguration', pipeline_response) + deserialized = self._deserialize("DscConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore @distributed_trace_async async def get_content( - self, - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - **kwargs: Any - ) -> str: + self, resource_group_name: str, automation_account_name: str, configuration_name: str, **kwargs: Any + ) -> AsyncIterator[bytes]: """Retrieve the configuration script identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The configuration name. + :param configuration_name: The configuration name. Required. :type configuration_name: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: str, or the result of cls(response) - :rtype: str - :raises: ~azure.core.exceptions.HttpResponseError + :return: Async iterator of the response bytes or the result of cls(response) + :rtype: AsyncIterator[bytes] + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[AsyncIterator[bytes]] - request = build_get_content_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, configuration_name=configuration_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_content.metadata['url'], + template_url=self.get_content.metadata["url"], headers=_headers, params=_params, ) @@ -425,25 +507,23 @@ async def get_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=True, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('str', pipeline_response) + deserialized = response.stream_download(self._client._pipeline) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}/content"} # type: ignore - + get_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}/content"} # type: ignore @distributed_trace def list_by_automation_account( @@ -455,12 +535,12 @@ def list_by_automation_account( top: Optional[int] = None, inlinecount: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.DscConfigurationListResult]: + ) -> AsyncIterable["_models.DscConfiguration"]: """Retrieve a list of configurations. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str @@ -470,39 +550,33 @@ def list_by_automation_account( :type top: int :param inlinecount: Return total rows. Default value is None. :type inlinecount: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscConfigurationListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscConfigurationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either DscConfiguration or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscConfiguration] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscConfigurationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscConfigurationListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, skip=skip, top=top, inlinecount=inlinecount, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -510,20 +584,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - skip=skip, - top=top, - inlinecount=inlinecount, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -539,10 +600,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -553,8 +612,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_node_configuration_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_node_configuration_operations.py index bf2f05b22974..69b21fd42ff9 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_node_configuration_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_node_configuration_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,11 +28,18 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._dsc_node_configuration_operations import build_create_or_update_request_initial, build_delete_request, build_get_request, build_list_by_automation_account_request +from ...operations._dsc_node_configuration_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class DscNodeConfigurationOperations: """ .. warning:: @@ -46,50 +59,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - node_configuration_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_configuration_name: str, **kwargs: Any ) -> None: """Delete the Dsc node configurations by node configuration. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_configuration_name: The Dsc node configuration name. + :param node_configuration_name: The Dsc node configuration name. Required. :type node_configuration_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_configuration_name=node_configuration_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -97,10 +99,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -111,52 +112,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - node_configuration_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_configuration_name: str, **kwargs: Any ) -> _models.DscNodeConfiguration: """Retrieve the Dsc node configurations by node configuration. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_configuration_name: The Dsc node configuration name. + :param node_configuration_name: The Dsc node configuration name. Required. :type node_configuration_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscNodeConfiguration, or the result of cls(response) + :return: DscNodeConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscNodeConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeConfiguration] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_configuration_name=node_configuration_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -164,10 +154,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -175,39 +164,42 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscNodeConfiguration', pipeline_response) + deserialized = self._deserialize("DscNodeConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore async def _create_or_update_initial( self, resource_group_name: str, automation_account_name: str, node_configuration_name: str, - parameters: _models.DscNodeConfigurationCreateOrUpdateParameters, + parameters: Union[_models.DscNodeConfigurationCreateOrUpdateParameters, IO], **kwargs: Any ) -> Optional[_models.DscNodeConfiguration]: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.DscNodeConfiguration]] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.DscNodeConfiguration]] - _json = self._serialize.body(parameters, 'DscNodeConfigurationCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "DscNodeConfigurationCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + request = build_create_or_update_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_configuration_name=node_configuration_name, @@ -215,7 +207,8 @@ async def _create_or_update_initial( api_version=api_version, content_type=content_type, json=_json, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -223,50 +216,51 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) deserialized = None if response.status_code == 201: - deserialized = self._deserialize('DscNodeConfiguration', pipeline_response) + deserialized = self._deserialize("DscNodeConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore - - @distributed_trace_async + @overload async def begin_create_or_update( self, resource_group_name: str, automation_account_name: str, node_configuration_name: str, parameters: _models.DscNodeConfigurationCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any - ) -> AsyncLROPoller[_models.DscNodeConfiguration]: + ) -> AsyncLROPoller[None]: """Create the node configuration identified by node configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_configuration_name: The Dsc node configuration name. + :param node_configuration_name: The Dsc node configuration name. Required. :type node_configuration_name: str - :param parameters: The create or update parameters for configuration. + :param parameters: The create or update parameters for configuration. Required. :type parameters: ~azure.mgmt.automation.models.DscNodeConfigurationCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -278,20 +272,93 @@ async def begin_create_or_update( :return: An instance of AsyncLROPoller that returns either DscNodeConfiguration or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.DscNodeConfiguration] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + node_configuration_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[None]: + """Create the node configuration identified by node configuration name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param node_configuration_name: The Dsc node configuration name. Required. + :type node_configuration_name: str + :param parameters: The create or update parameters for configuration. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either DscNodeConfiguration or the result + of cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.DscNodeConfiguration] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + node_configuration_name: str, + parameters: Union[_models.DscNodeConfigurationCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> AsyncLROPoller[None]: + """Create the node configuration identified by node configuration name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param node_configuration_name: The Dsc node configuration name. Required. + :type node_configuration_name: str + :param parameters: The create or update parameters for configuration. Is either a model type or + a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.DscNodeConfigurationCreateOrUpdateParameters or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either DscNodeConfiguration or the result + of cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.DscNodeConfiguration] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeConfiguration] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -300,39 +367,35 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('DscNodeConfiguration', pipeline_response) + deserialized = self._deserialize("DscNodeConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore @distributed_trace def list_by_automation_account( @@ -344,12 +407,12 @@ def list_by_automation_account( top: Optional[int] = None, inlinecount: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.DscNodeConfigurationListResult]: + ) -> AsyncIterable["_models.DscNodeConfiguration"]: """Retrieve a list of dsc node configurations. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str @@ -359,39 +422,35 @@ def list_by_automation_account( :type top: int :param inlinecount: Return total rows. Default value is None. :type inlinecount: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscNodeConfigurationListResult or the result of + :return: An iterator like instance of either DscNodeConfiguration or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscNodeConfigurationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscNodeConfiguration] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeConfigurationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeConfigurationListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, skip=skip, top=top, inlinecount=inlinecount, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -399,20 +458,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - skip=skip, - top=top, - inlinecount=inlinecount, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -428,10 +474,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -442,8 +486,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_node_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_node_operations.py index e9c00950ccb5..5e11e3613c33 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_node_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_dsc_node_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,18 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._dsc_node_operations import build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._dsc_node_operations import ( + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class DscNodeOperations: """ .. warning:: @@ -44,50 +57,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - node_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_id: str, **kwargs: Any ) -> None: """Delete the dsc node identified by node id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The node id. + :param node_id: The node id. Required. :type node_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_id=node_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +97,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,52 +110,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - node_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_id: str, **kwargs: Any ) -> _models.DscNode: """Retrieve the dsc node identified by node id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The node id. + :param node_id: The node id. Required. :type node_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscNode, or the result of cls(response) + :return: DscNode or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscNode - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNode] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNode] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_id=node_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +152,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,56 +162,120 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscNode', pipeline_response) + deserialized = self._deserialize("DscNode", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore - - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, node_id: str, dsc_node_update_parameters: _models.DscNodeUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.DscNode: """Update the dsc node. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: Parameters supplied to the update dsc node. + :param node_id: Parameters supplied to the update dsc node. Required. :type node_id: str - :param dsc_node_update_parameters: Parameters supplied to the update dsc node. + :param dsc_node_update_parameters: Parameters supplied to the update dsc node. Required. :type dsc_node_update_parameters: ~azure.mgmt.automation.models.DscNodeUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscNode or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscNode + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + node_id: str, + dsc_node_update_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.DscNode: + """Update the dsc node. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param node_id: Parameters supplied to the update dsc node. Required. + :type node_id: str + :param dsc_node_update_parameters: Parameters supplied to the update dsc node. Required. + :type dsc_node_update_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscNode or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscNode + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + node_id: str, + dsc_node_update_parameters: Union[_models.DscNodeUpdateParameters, IO], + **kwargs: Any + ) -> _models.DscNode: + """Update the dsc node. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param node_id: Parameters supplied to the update dsc node. Required. + :type node_id: str + :param dsc_node_update_parameters: Parameters supplied to the update dsc node. Is either a + model type or a IO type. Required. + :type dsc_node_update_parameters: ~azure.mgmt.automation.models.DscNodeUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscNode, or the result of cls(response) + :return: DscNode or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscNode - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNode] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNode] - _json = self._serialize.body(dsc_node_update_parameters, 'DscNodeUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(dsc_node_update_parameters, (IO, bytes)): + _content = dsc_node_update_parameters + else: + _json = self._serialize.body(dsc_node_update_parameters, "DscNodeUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -232,7 +285,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -240,10 +294,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -251,15 +304,14 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscNode', pipeline_response) + deserialized = self._deserialize("DscNode", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore @distributed_trace def list_by_automation_account( @@ -271,12 +323,12 @@ def list_by_automation_account( top: Optional[int] = None, inlinecount: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.DscNodeListResult]: + ) -> AsyncIterable["_models.DscNode"]: """Retrieve a list of dsc nodes. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str @@ -286,38 +338,33 @@ def list_by_automation_account( :type top: int :param inlinecount: Return total rows. Default value is None. :type inlinecount: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscNodeListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscNodeListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either DscNode or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscNode] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, skip=skip, top=top, inlinecount=inlinecount, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -325,20 +372,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - skip=skip, - top=top, - inlinecount=inlinecount, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -354,10 +388,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -368,8 +400,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_fields_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_fields_operations.py index 5d0643cc92b1..a6c6f9175a97 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_fields_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_fields_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -21,9 +27,11 @@ from ..._vendor import _convert_request from ...operations._fields_operations import build_list_by_type_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class FieldsOperations: """ .. warning:: @@ -43,48 +51,37 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_type( - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - type_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.TypeFieldListResult]: + self, resource_group_name: str, automation_account_name: str, module_name: str, type_name: str, **kwargs: Any + ) -> AsyncIterable["_models.TypeField"]: """Retrieve a list of fields of a given type identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param type_name: The name of type. + :param type_name: The name of type. Required. :type type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either TypeFieldListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.TypeFieldListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either TypeField or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.TypeField] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.TypeFieldListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.TypeFieldListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_type_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -92,7 +89,7 @@ def prepare_request(next_link=None): type_name=type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_type.metadata['url'], + template_url=self.list_by_type.metadata["url"], headers=_headers, params=_params, ) @@ -100,18 +97,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_type_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - module_name=module_name, - type_name=type_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -127,10 +113,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -141,8 +125,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_type.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/types/{typeName}/fields"} # type: ignore + list_by_type.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/types/{typeName}/fields"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_hybrid_runbook_worker_group_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_hybrid_runbook_worker_group_operations.py index cc8d53f6df19..4d73cfd59ecd 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_hybrid_runbook_worker_group_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_hybrid_runbook_worker_group_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._hybrid_runbook_worker_group_operations import build_create_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._hybrid_runbook_worker_group_operations import ( + build_create_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class HybridRunbookWorkerGroupOperations: """ .. warning:: @@ -44,7 +58,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements self, @@ -55,39 +68,33 @@ async def delete( # pylint: disable=inconsistent-return-statements ) -> None: """Delete a hybrid runbook worker group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, hybrid_runbook_worker_group_name=hybrid_runbook_worker_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +102,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,8 +115,7 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore @distributed_trace_async async def get( @@ -122,39 +127,33 @@ async def get( ) -> _models.HybridRunbookWorkerGroup: """Retrieve a hybrid runbook worker group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorkerGroup, or the result of cls(response) + :return: HybridRunbookWorkerGroup or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkerGroup] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkerGroup] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, hybrid_runbook_worker_group_name=hybrid_runbook_worker_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +161,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,58 +171,128 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorkerGroup', pipeline_response) + deserialized = self._deserialize("HybridRunbookWorkerGroup", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore - @distributed_trace_async + @overload async def create( self, resource_group_name: str, automation_account_name: str, hybrid_runbook_worker_group_name: str, hybrid_runbook_worker_group_creation_parameters: _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.HybridRunbookWorkerGroup: """Create a hybrid runbook worker group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str :param hybrid_runbook_worker_group_creation_parameters: The create or update parameters for - hybrid runbook worker group. + hybrid runbook worker group. Required. :type hybrid_runbook_worker_group_creation_parameters: ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorkerGroup or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_group_creation_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.HybridRunbookWorkerGroup: + """Create a hybrid runbook worker group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_group_creation_parameters: The create or update parameters for + hybrid runbook worker group. Required. + :type hybrid_runbook_worker_group_creation_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorkerGroup or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_group_creation_parameters: Union[ + _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, IO + ], + **kwargs: Any + ) -> _models.HybridRunbookWorkerGroup: + """Create a hybrid runbook worker group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_group_creation_parameters: The create or update parameters for + hybrid runbook worker group. Is either a model type or a IO type. Required. + :type hybrid_runbook_worker_group_creation_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorkerGroup, or the result of cls(response) + :return: HybridRunbookWorkerGroup or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkerGroup] - - _json = self._serialize.body(hybrid_runbook_worker_group_creation_parameters, 'HybridRunbookWorkerGroupCreateOrUpdateParameters') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkerGroup] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(hybrid_runbook_worker_group_creation_parameters, (IO, bytes)): + _content = hybrid_runbook_worker_group_creation_parameters + else: + _json = self._serialize.body( + hybrid_runbook_worker_group_creation_parameters, "HybridRunbookWorkerGroupCreateOrUpdateParameters" + ) request = build_create_request( resource_group_name=resource_group_name, @@ -234,7 +302,8 @@ async def create( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -242,26 +311,91 @@ async def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response - if response.status_code not in [200]: + if response.status_code not in [200, 201]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorkerGroup', pipeline_response) + if response.status_code == 200: + deserialized = self._deserialize("HybridRunbookWorkerGroup", pipeline_response) + + if response.status_code == 201: + deserialized = self._deserialize("HybridRunbookWorkerGroup", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_group_updation_parameters: _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.HybridRunbookWorkerGroup: + """Update a hybrid runbook worker group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_group_updation_parameters: The hybrid runbook worker group. + Required. + :type hybrid_runbook_worker_group_updation_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorkerGroup or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_group_updation_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.HybridRunbookWorkerGroup: + """Update a hybrid runbook worker group. + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_group_updation_parameters: The hybrid runbook worker group. + Required. + :type hybrid_runbook_worker_group_updation_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorkerGroup or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup + :raises ~azure.core.exceptions.HttpResponseError: + """ @distributed_trace_async async def update( @@ -269,41 +403,50 @@ async def update( resource_group_name: str, automation_account_name: str, hybrid_runbook_worker_group_name: str, - parameters: _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, + hybrid_runbook_worker_group_updation_parameters: Union[ + _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, IO + ], **kwargs: Any ) -> _models.HybridRunbookWorkerGroup: """Update a hybrid runbook worker group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param parameters: The hybrid runbook worker group. - :type parameters: - ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :param hybrid_runbook_worker_group_updation_parameters: The hybrid runbook worker group. Is + either a model type or a IO type. Required. + :type hybrid_runbook_worker_group_updation_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorkerGroup, or the result of cls(response) + :return: HybridRunbookWorkerGroup or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkerGroup] - - _json = self._serialize.body(parameters, 'HybridRunbookWorkerGroupCreateOrUpdateParameters') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkerGroup] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(hybrid_runbook_worker_group_updation_parameters, (IO, bytes)): + _content = hybrid_runbook_worker_group_updation_parameters + else: + _json = self._serialize.body( + hybrid_runbook_worker_group_updation_parameters, "HybridRunbookWorkerGroupCreateOrUpdateParameters" + ) request = build_update_request( resource_group_name=resource_group_name, @@ -313,7 +456,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -321,10 +465,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -332,62 +475,53 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorkerGroup', pipeline_response) + deserialized = self._deserialize("HybridRunbookWorkerGroup", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> AsyncIterable[_models.HybridRunbookWorkerGroupsListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.HybridRunbookWorkerGroup"]: """Retrieve a list of hybrid runbook worker groups. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either HybridRunbookWorkerGroupsListResult or the result - of cls(response) + :return: An iterator like instance of either HybridRunbookWorkerGroup or the result of + cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.HybridRunbookWorkerGroupsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.HybridRunbookWorkerGroup] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkerGroupsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkerGroupsListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -395,17 +529,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -421,10 +545,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -435,8 +557,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_hybrid_runbook_workers_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_hybrid_runbook_workers_operations.py index f909014d5411..bf9d6bee44f2 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_hybrid_runbook_workers_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_hybrid_runbook_workers_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._hybrid_runbook_workers_operations import build_create_request, build_delete_request, build_get_request, build_list_by_hybrid_runbook_worker_group_request, build_move_request +from ...operations._hybrid_runbook_workers_operations import ( + build_create_request, + build_delete_request, + build_get_request, + build_list_by_hybrid_runbook_worker_group_request, + build_move_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class HybridRunbookWorkersOperations: """ .. warning:: @@ -44,7 +58,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements self, @@ -56,34 +69,28 @@ async def delete( # pylint: disable=inconsistent-return-statements ) -> None: """Delete a hybrid runbook worker. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param hybrid_runbook_worker_id: The hybrid runbook worker id. + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. :type hybrid_runbook_worker_id: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -91,7 +98,7 @@ async def delete( # pylint: disable=inconsistent-return-statements hybrid_runbook_worker_id=hybrid_runbook_worker_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -99,10 +106,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -113,8 +119,7 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore @distributed_trace_async async def get( @@ -127,34 +132,28 @@ async def get( ) -> _models.HybridRunbookWorker: """Retrieve a hybrid runbook worker. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param hybrid_runbook_worker_id: The hybrid runbook worker id. + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. :type hybrid_runbook_worker_id: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorker, or the result of cls(response) + :return: HybridRunbookWorker or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorker - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorker] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorker] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -162,7 +161,7 @@ async def get( hybrid_runbook_worker_id=hybrid_runbook_worker_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -170,10 +169,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -181,17 +179,16 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorker', pipeline_response) + deserialized = self._deserialize("HybridRunbookWorker", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore - @distributed_trace_async + @overload async def create( self, resource_group_name: str, @@ -199,43 +196,118 @@ async def create( hybrid_runbook_worker_group_name: str, hybrid_runbook_worker_id: str, hybrid_runbook_worker_creation_parameters: _models.HybridRunbookWorkerCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.HybridRunbookWorker: """Create a hybrid runbook worker. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param hybrid_runbook_worker_id: The hybrid runbook worker id. + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. :type hybrid_runbook_worker_id: str :param hybrid_runbook_worker_creation_parameters: The create or update parameters for hybrid - runbook worker. + runbook worker. Required. :type hybrid_runbook_worker_creation_parameters: ~azure.mgmt.automation.models.HybridRunbookWorkerCreateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorker or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorker + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_id: str, + hybrid_runbook_worker_creation_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.HybridRunbookWorker: + """Create a hybrid runbook worker. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. + :type hybrid_runbook_worker_id: str + :param hybrid_runbook_worker_creation_parameters: The create or update parameters for hybrid + runbook worker. Required. + :type hybrid_runbook_worker_creation_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorker or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorker + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_id: str, + hybrid_runbook_worker_creation_parameters: Union[_models.HybridRunbookWorkerCreateParameters, IO], + **kwargs: Any + ) -> _models.HybridRunbookWorker: + """Create a hybrid runbook worker. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. + :type hybrid_runbook_worker_id: str + :param hybrid_runbook_worker_creation_parameters: The create or update parameters for hybrid + runbook worker. Is either a model type or a IO type. Required. + :type hybrid_runbook_worker_creation_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorker, or the result of cls(response) + :return: HybridRunbookWorker or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorker - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorker] - - _json = self._serialize.body(hybrid_runbook_worker_creation_parameters, 'HybridRunbookWorkerCreateParameters') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorker] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(hybrid_runbook_worker_creation_parameters, (IO, bytes)): + _content = hybrid_runbook_worker_creation_parameters + else: + _json = self._serialize.body( + hybrid_runbook_worker_creation_parameters, "HybridRunbookWorkerCreateParameters" + ) request = build_create_request( resource_group_name=resource_group_name, @@ -246,7 +318,8 @@ async def create( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -254,28 +327,30 @@ async def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response - if response.status_code not in [200]: + if response.status_code not in [200, 201]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorker', pipeline_response) + if response.status_code == 200: + deserialized = self._deserialize("HybridRunbookWorker", pipeline_response) + + if response.status_code == 201: + deserialized = self._deserialize("HybridRunbookWorker", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore - - @distributed_trace_async + @overload async def move( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, @@ -283,42 +358,116 @@ async def move( # pylint: disable=inconsistent-return-statements hybrid_runbook_worker_group_name: str, hybrid_runbook_worker_id: str, hybrid_runbook_worker_move_parameters: _models.HybridRunbookWorkerMoveParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> None: """Move a hybrid worker to a different group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param hybrid_runbook_worker_id: The hybrid runbook worker id. + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. :type hybrid_runbook_worker_id: str :param hybrid_runbook_worker_move_parameters: The hybrid runbook worker move parameters. + Required. :type hybrid_runbook_worker_move_parameters: ~azure.mgmt.automation.models.HybridRunbookWorkerMoveParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def move( # pylint: disable=inconsistent-return-statements + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_id: str, + hybrid_runbook_worker_move_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Move a hybrid worker to a different group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. + :type hybrid_runbook_worker_id: str + :param hybrid_runbook_worker_move_parameters: The hybrid runbook worker move parameters. + Required. + :type hybrid_runbook_worker_move_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def move( # pylint: disable=inconsistent-return-statements + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_id: str, + hybrid_runbook_worker_move_parameters: Union[_models.HybridRunbookWorkerMoveParameters, IO], + **kwargs: Any + ) -> None: + """Move a hybrid worker to a different group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. + :type hybrid_runbook_worker_id: str + :param hybrid_runbook_worker_move_parameters: The hybrid runbook worker move parameters. Is + either a model type or a IO type. Required. + :type hybrid_runbook_worker_move_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerMoveParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] - _json = self._serialize.body(hybrid_runbook_worker_move_parameters, 'HybridRunbookWorkerMoveParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(hybrid_runbook_worker_move_parameters, (IO, bytes)): + _content = hybrid_runbook_worker_move_parameters + else: + _json = self._serialize.body(hybrid_runbook_worker_move_parameters, "HybridRunbookWorkerMoveParameters") request = build_move_request( resource_group_name=resource_group_name, @@ -329,7 +478,8 @@ async def move( # pylint: disable=inconsistent-return-statements api_version=api_version, content_type=content_type, json=_json, - template_url=self.move.metadata['url'], + content=_content, + template_url=self.move.metadata["url"], headers=_headers, params=_params, ) @@ -337,10 +487,9 @@ async def move( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -351,8 +500,7 @@ async def move( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - move.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}/move"} # type: ignore - + move.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}/move"} # type: ignore @distributed_trace def list_by_hybrid_runbook_worker_group( @@ -362,48 +510,43 @@ def list_by_hybrid_runbook_worker_group( hybrid_runbook_worker_group_name: str, filter: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.HybridRunbookWorkersListResult]: + ) -> AsyncIterable["_models.HybridRunbookWorker"]: """Retrieve a list of hybrid runbook workers. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either HybridRunbookWorkersListResult or the result of - cls(response) + :return: An iterator like instance of either HybridRunbookWorker or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.HybridRunbookWorkersListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.HybridRunbookWorker] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkersListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkersListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_hybrid_runbook_worker_group_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, hybrid_runbook_worker_group_name=hybrid_runbook_worker_group_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_hybrid_runbook_worker_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_hybrid_runbook_worker_group.metadata["url"], headers=_headers, params=_params, ) @@ -411,18 +554,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_hybrid_runbook_worker_group_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - hybrid_runbook_worker_group_name=hybrid_runbook_worker_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -438,10 +570,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -452,8 +582,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_hybrid_runbook_worker_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers"} # type: ignore + list_by_hybrid_runbook_worker_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_operations.py index 34cc6818aa98..203ced1dcf17 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,22 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._job_operations import build_create_request, build_get_output_request, build_get_request, build_get_runbook_content_request, build_list_by_automation_account_request, build_resume_request, build_stop_request, build_suspend_request +from ...operations._job_operations import ( + build_create_request, + build_get_output_request, + build_get_request, + build_get_runbook_content_request, + build_list_by_automation_account_request, + build_resume_request, + build_stop_request, + build_suspend_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class JobOperations: """ .. warning:: @@ -44,7 +61,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get_output( self, @@ -56,42 +72,36 @@ async def get_output( ) -> str: """Retrieve the job output identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The name of the job to be created. + :param job_name: The name of the job to be created. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: str, or the result of cls(response) + :return: str or the result of cls(response) :rtype: str - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[str] - request = build_get_output_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_output.metadata['url'], + api_version=api_version, + template_url=self.get_output.metadata["url"], headers=_headers, params=_params, ) @@ -99,25 +109,23 @@ async def get_output( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('str', pipeline_response) + deserialized = self._deserialize("str", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_output.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/output"} # type: ignore - + get_output.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/output"} # type: ignore @distributed_trace_async async def get_runbook_content( @@ -130,42 +138,36 @@ async def get_runbook_content( ) -> str: """Retrieve the runbook content of the job identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: str, or the result of cls(response) + :return: str or the result of cls(response) :rtype: str - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[str] - request = build_get_runbook_content_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_runbook_content.metadata['url'], + api_version=api_version, + template_url=self.get_runbook_content.metadata["url"], headers=_headers, params=_params, ) @@ -173,25 +175,23 @@ async def get_runbook_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('str', pipeline_response) + deserialized = self._deserialize("str", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_runbook_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/runbookContent"} # type: ignore - + get_runbook_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/runbookContent"} # type: ignore @distributed_trace_async async def suspend( # pylint: disable=inconsistent-return-statements @@ -204,42 +204,36 @@ async def suspend( # pylint: disable=inconsistent-return-statements ) -> None: """Suspend the job identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_suspend_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.suspend.metadata['url'], + api_version=api_version, + template_url=self.suspend.metadata["url"], headers=_headers, params=_params, ) @@ -247,10 +241,9 @@ async def suspend( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -261,8 +254,7 @@ async def suspend( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - suspend.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/suspend"} # type: ignore - + suspend.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/suspend"} # type: ignore @distributed_trace_async async def stop( # pylint: disable=inconsistent-return-statements @@ -275,42 +267,36 @@ async def stop( # pylint: disable=inconsistent-return-statements ) -> None: """Stop the job identified by jobName. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_stop_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, subscription_id=self._config.subscription_id, - api_version=api_version, client_request_id=client_request_id, - template_url=self.stop.metadata['url'], + api_version=api_version, + template_url=self.stop.metadata["url"], headers=_headers, params=_params, ) @@ -318,10 +304,9 @@ async def stop( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -332,8 +317,7 @@ async def stop( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - stop.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/stop"} # type: ignore - + stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/stop"} # type: ignore @distributed_trace_async async def get( @@ -346,42 +330,36 @@ async def get( ) -> _models.Job: """Retrieve the job identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Job, or the result of cls(response) + :return: Job or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Job - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Job] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Job] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get.metadata['url'], + api_version=api_version, + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -389,10 +367,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -400,17 +377,16 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Job', pipeline_response) + deserialized = self._deserialize("Job", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}"} # type: ignore - - @distributed_trace_async + @overload async def create( self, resource_group_name: str, @@ -418,52 +394,124 @@ async def create( job_name: str, parameters: _models.JobCreateParameters, client_request_id: Optional[str] = None, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Job: """Create a job of the runbook. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str - :param parameters: The parameters supplied to the create job operation. + :param parameters: The parameters supplied to the create job operation. Required. :type parameters: ~azure.mgmt.automation.models.JobCreateParameters :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Job or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Job + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create( + self, + resource_group_name: str, + automation_account_name: str, + job_name: str, + parameters: IO, + client_request_id: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Job: + """Create a job of the runbook. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param job_name: The job name. Required. + :type job_name: str + :param parameters: The parameters supplied to the create job operation. Required. + :type parameters: IO + :param client_request_id: Identifies this specific client request. Default value is None. + :type client_request_id: str + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Job or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Job + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + automation_account_name: str, + job_name: str, + parameters: Union[_models.JobCreateParameters, IO], + client_request_id: Optional[str] = None, + **kwargs: Any + ) -> _models.Job: + """Create a job of the runbook. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param job_name: The job name. Required. + :type job_name: str + :param parameters: The parameters supplied to the create job operation. Is either a model type + or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.JobCreateParameters or IO + :param client_request_id: Identifies this specific client request. Default value is None. + :type client_request_id: str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Job, or the result of cls(response) + :return: Job or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Job - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Job] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Job] - _json = self._serialize.body(parameters, 'JobCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "JobCreateParameters") request = build_create_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, + subscription_id=self._config.subscription_id, + client_request_id=client_request_id, api_version=api_version, content_type=content_type, json=_json, - client_request_id=client_request_id, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -471,10 +519,9 @@ async def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -482,15 +529,14 @@ async def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Job', pipeline_response) + deserialized = self._deserialize("Job", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}"} # type: ignore @distributed_trace def list_by_automation_account( @@ -500,46 +546,43 @@ def list_by_automation_account( filter: Optional[str] = None, client_request_id: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.JobListResultV2]: + ) -> AsyncIterable["_models.JobCollectionItem"]: """Retrieve a list of jobs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either JobListResultV2 or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.JobListResultV2] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either JobCollectionItem or the result of cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.JobCollectionItem] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobListResultV2] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobListResultV2] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, client_request_id=client_request_id, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -547,18 +590,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - client_request_id=client_request_id, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -574,10 +606,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -588,11 +618,9 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs"} # type: ignore @distributed_trace_async async def resume( # pylint: disable=inconsistent-return-statements @@ -605,42 +633,36 @@ async def resume( # pylint: disable=inconsistent-return-statements ) -> None: """Resume the job identified by jobName. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_resume_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, subscription_id=self._config.subscription_id, - api_version=api_version, client_request_id=client_request_id, - template_url=self.resume.metadata['url'], + api_version=api_version, + template_url=self.resume.metadata["url"], headers=_headers, params=_params, ) @@ -648,10 +670,9 @@ async def resume( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -662,5 +683,4 @@ async def resume( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - resume.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/resume"} # type: ignore - + resume.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/resume"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_schedule_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_schedule_operations.py index b003b08a9002..e46500790419 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_schedule_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_schedule_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,18 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._job_schedule_operations import build_create_request, build_delete_request, build_get_request, build_list_by_automation_account_request +from ...operations._job_schedule_operations import ( + build_create_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class JobScheduleOperations: """ .. warning:: @@ -44,50 +57,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - job_schedule_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, job_schedule_id: str, **kwargs: Any ) -> None: """Delete the job schedule identified by job schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_schedule_id: The job schedule name. + :param job_schedule_id: The job schedule name. Required. :type job_schedule_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_schedule_id=job_schedule_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +97,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,52 +110,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - job_schedule_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, job_schedule_id: str, **kwargs: Any ) -> _models.JobSchedule: """Retrieve the job schedule identified by job schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_schedule_id: The job schedule name. + :param job_schedule_id: The job schedule name. Required. :type job_schedule_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobSchedule, or the result of cls(response) + :return: JobSchedule or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobSchedule - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobSchedule] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobSchedule] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_schedule_id=job_schedule_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +152,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,56 +162,120 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobSchedule', pipeline_response) + deserialized = self._deserialize("JobSchedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore - - @distributed_trace_async + @overload async def create( self, resource_group_name: str, automation_account_name: str, job_schedule_id: str, parameters: _models.JobScheduleCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.JobSchedule: """Create a job schedule. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_schedule_id: The job schedule name. + :param job_schedule_id: The job schedule name. Required. :type job_schedule_id: str - :param parameters: The parameters supplied to the create job schedule operation. + :param parameters: The parameters supplied to the create job schedule operation. Required. :type parameters: ~azure.mgmt.automation.models.JobScheduleCreateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobSchedule, or the result of cls(response) + :return: JobSchedule or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobSchedule - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def create( + self, + resource_group_name: str, + automation_account_name: str, + job_schedule_id: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.JobSchedule: + """Create a job schedule. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param job_schedule_id: The job schedule name. Required. + :type job_schedule_id: str + :param parameters: The parameters supplied to the create job schedule operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: JobSchedule or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.JobSchedule + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + automation_account_name: str, + job_schedule_id: str, + parameters: Union[_models.JobScheduleCreateParameters, IO], + **kwargs: Any + ) -> _models.JobSchedule: + """Create a job schedule. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param job_schedule_id: The job schedule name. Required. + :type job_schedule_id: str + :param parameters: The parameters supplied to the create job schedule operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.JobScheduleCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: JobSchedule or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.JobSchedule + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobSchedule] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobSchedule] - _json = self._serialize.body(parameters, 'JobScheduleCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "JobScheduleCreateParameters") request = build_create_request( resource_group_name=resource_group_name, @@ -232,7 +285,8 @@ async def create( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -240,10 +294,9 @@ async def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -251,62 +304,51 @@ async def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobSchedule', pipeline_response) + deserialized = self._deserialize("JobSchedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> AsyncIterable[_models.JobScheduleListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.JobSchedule"]: """Retrieve a list of job schedules. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either JobScheduleListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.JobScheduleListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either JobSchedule or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.JobSchedule] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobScheduleListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobScheduleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -314,17 +356,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -340,10 +372,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -354,8 +384,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_stream_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_stream_operations.py index 3fc7d7371428..82270608375d 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_stream_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_job_stream_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -22,9 +28,11 @@ from ..._vendor import _convert_request from ...operations._job_stream_operations import build_get_request, build_list_by_job_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class JobStreamOperations: """ .. warning:: @@ -44,7 +52,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get( self, @@ -57,45 +64,39 @@ async def get( ) -> _models.JobStream: """Retrieve the job stream identified by job stream id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str - :param job_stream_id: The job stream id. + :param job_stream_id: The job stream id. Required. :type job_stream_id: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobStream, or the result of cls(response) + :return: JobStream or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobStream - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStream] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStream] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, job_stream_id=job_stream_id, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get.metadata['url'], + api_version=api_version, + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -103,10 +104,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -114,15 +114,14 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobStream', pipeline_response) + deserialized = self._deserialize("JobStream", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams/{jobStreamId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams/{jobStreamId}"} # type: ignore @distributed_trace def list_by_job( @@ -133,50 +132,45 @@ def list_by_job( filter: Optional[str] = None, client_request_id: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.JobStreamListResult]: + ) -> AsyncIterable["_models.JobStream"]: """Retrieve a list of jobs streams identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either JobStreamListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.JobStreamListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either JobStream or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.JobStream] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStreamListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStreamListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_job_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, client_request_id=client_request_id, - template_url=self.list_by_job.metadata['url'], + api_version=api_version, + template_url=self.list_by_job.metadata["url"], headers=_headers, params=_params, ) @@ -184,19 +178,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_job_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - job_name=job_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - client_request_id=client_request_id, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -212,10 +194,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -226,8 +206,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_job.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams"} # type: ignore + list_by_job.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_keys_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_keys_operations.py index dd8b6399aa63..4e2e5a8209df 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_keys_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_keys_operations.py @@ -8,7 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +26,11 @@ from ..._vendor import _convert_request from ...operations._keys_operations import build_list_by_automation_account_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class KeysOperations: """ .. warning:: @@ -42,46 +50,36 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, **kwargs: Any ) -> _models.KeyListResult: """Retrieve the automation keys for an account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: KeyListResult, or the result of cls(response) + :return: KeyListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.KeyListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] - request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -89,10 +87,9 @@ async def list_by_automation_account( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -100,12 +97,11 @@ async def list_by_automation_account( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('KeyListResult', pipeline_response) + deserialized = self._deserialize("KeyListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/listKeys"} # type: ignore - + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/listKeys"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_linked_workspace_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_linked_workspace_operations.py index b9c8bb391494..34bf202f8daf 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_linked_workspace_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_linked_workspace_operations.py @@ -8,7 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +26,11 @@ from ..._vendor import _convert_request from ...operations._linked_workspace_operations import build_get_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class LinkedWorkspaceOperations: """ .. warning:: @@ -42,46 +50,36 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, **kwargs: Any ) -> _models.LinkedWorkspace: """Retrieve the linked workspace for the account id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: LinkedWorkspace, or the result of cls(response) + :return: LinkedWorkspace or the result of cls(response) :rtype: ~azure.mgmt.automation.models.LinkedWorkspace - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.LinkedWorkspace] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.LinkedWorkspace] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -89,10 +87,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -100,12 +97,11 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('LinkedWorkspace', pipeline_response) + deserialized = self._deserialize("LinkedWorkspace", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/linkedWorkspace"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/linkedWorkspace"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_module_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_module_operations.py index bad8f9db3f4e..0abf20b93986 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_module_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_module_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._module_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._module_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ModuleOperations: """ .. warning:: @@ -44,50 +58,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, module_name: str, **kwargs: Any ) -> None: """Delete the module by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The module name. + :param module_name: The module name. Required. :type module_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, module_name=module_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +98,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,52 +111,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, module_name: str, **kwargs: Any ) -> _models.Module: """Retrieve the module identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The module name. + :param module_name: The module name. Required. :type module_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, module_name=module_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +153,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,56 +163,120 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, module_name: str, parameters: _models.ModuleCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Module: """Create or Update the module identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param parameters: The create or update parameters for module. + :param parameters: The create or update parameters for module. Required. :type parameters: ~azure.mgmt.automation.models.ModuleCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + module_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Create or Update the module identified by module name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param module_name: The name of module. Required. + :type module_name: str + :param parameters: The create or update parameters for module. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + module_name: str, + parameters: Union[_models.ModuleCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Create or Update the module identified by module name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param module_name: The name of module. Required. + :type module_name: str + :param parameters: The create or update parameters for module. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.ModuleCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - _json = self._serialize.body(parameters, 'ModuleCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ModuleCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -232,7 +286,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -240,10 +295,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -252,59 +306,123 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, module_name: str, parameters: _models.ModuleUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Module: """Update the module identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param parameters: The update parameters for module. + :param parameters: The update parameters for module. Required. :type parameters: ~azure.mgmt.automation.models.ModuleUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + module_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Update the module identified by module name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param module_name: The name of module. Required. + :type module_name: str + :param parameters: The update parameters for module. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + module_name: str, + parameters: Union[_models.ModuleUpdateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Update the module identified by module name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param module_name: The name of module. Required. + :type module_name: str + :param parameters: The update parameters for module. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.automation.models.ModuleUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - _json = self._serialize.body(parameters, 'ModuleUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ModuleUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -314,7 +432,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -322,10 +441,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -333,56 +451,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.ModuleListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Module"]: """Retrieve a list of modules. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ModuleListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.ModuleListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Module or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Module] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ModuleListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ModuleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -390,16 +500,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -415,10 +516,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -429,8 +528,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_node_count_information_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_node_count_information_operations.py index da42a224df54..21de638018eb 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_node_count_information_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_node_count_information_operations.py @@ -8,7 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar, Union -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +26,11 @@ from ..._vendor import _convert_request from ...operations._node_count_information_operations import build_get_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class NodeCountInformationOperations: """ .. warning:: @@ -42,7 +50,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get( self, @@ -53,39 +60,34 @@ async def get( ) -> _models.NodeCounts: """Retrieve counts for Dsc Nodes. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param count_type: The type of counts to retrieve. + :param count_type: The type of counts to retrieve. Known values are: "status" and + "nodeconfiguration". Required. :type count_type: str or ~azure.mgmt.automation.models.CountType - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: NodeCounts, or the result of cls(response) + :return: NodeCounts or the result of cls(response) :rtype: ~azure.mgmt.automation.models.NodeCounts - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.NodeCounts] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.NodeCounts] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, count_type=count_type, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -93,10 +95,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -104,12 +105,11 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('NodeCounts', pipeline_response) + deserialized = self._deserialize("NodeCounts", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodecounts/{countType}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodecounts/{countType}"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_node_reports_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_node_reports_operations.py index 6077045b23e9..cfa14f922959 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_node_reports_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_node_reports_operations.py @@ -6,10 +6,17 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +import sys from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +27,22 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._node_reports_operations import build_get_content_request, build_get_request, build_list_by_node_request +from ...operations._node_reports_operations import ( + build_get_content_request, + build_get_request, + build_list_by_node_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping +else: + from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports +JSON = MutableMapping[str, Any] # pylint: disable=unsubscriptable-object +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class NodeReportsOperations: """ .. warning:: @@ -44,7 +62,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_node( self, @@ -53,48 +70,42 @@ def list_by_node( node_id: str, filter: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.DscNodeReportListResult]: + ) -> AsyncIterable["_models.DscNodeReport"]: """Retrieve the Dsc node report list by node id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The parameters supplied to the list operation. + :param node_id: The parameters supplied to the list operation. Required. :type node_id: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscNodeReportListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscNodeReportListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either DscNodeReport or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscNodeReport] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeReportListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeReportListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_node_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_id=node_id, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_node.metadata['url'], + api_version=api_version, + template_url=self.list_by_node.metadata["url"], headers=_headers, params=_params, ) @@ -102,18 +113,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_node_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - node_id=node_id, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -129,10 +129,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -143,51 +141,38 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_node.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports"} # type: ignore + list_by_node.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - node_id: str, - report_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_id: str, report_id: str, **kwargs: Any ) -> _models.DscNodeReport: """Retrieve the Dsc node report data by node id and report id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The Dsc node id. + :param node_id: The Dsc node id. Required. :type node_id: str - :param report_id: The report id. + :param report_id: The report id. Required. :type report_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscNodeReport, or the result of cls(response) + :return: DscNodeReport or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscNodeReport - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeReport] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeReport] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -195,7 +180,7 @@ async def get( report_id=report_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -203,10 +188,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -214,55 +198,43 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscNodeReport', pipeline_response) + deserialized = self._deserialize("DscNodeReport", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}"} # type: ignore @distributed_trace_async async def get_content( - self, - resource_group_name: str, - automation_account_name: str, - node_id: str, - report_id: str, - **kwargs: Any - ) -> Any: + self, resource_group_name: str, automation_account_name: str, node_id: str, report_id: str, **kwargs: Any + ) -> JSON: """Retrieve the Dsc node reports by node id and report id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The Dsc node id. + :param node_id: The Dsc node id. Required. :type node_id: str - :param report_id: The report id. + :param report_id: The report id. Required. :type report_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: any, or the result of cls(response) - :rtype: any - :raises: ~azure.core.exceptions.HttpResponseError + :return: JSON or the result of cls(response) + :rtype: JSON + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Any] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[JSON] - request = build_get_content_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -270,7 +242,7 @@ async def get_content( report_id=report_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_content.metadata['url'], + template_url=self.get_content.metadata["url"], headers=_headers, params=_params, ) @@ -278,10 +250,9 @@ async def get_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -289,12 +260,11 @@ async def get_content( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('object', pipeline_response) + deserialized = self._deserialize("object", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}/content"} # type: ignore - + get_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}/content"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_object_data_types_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_object_data_types_operations.py index 1d2820ca017b..50b3cb6a852e 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_object_data_types_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_object_data_types_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -19,11 +25,16 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._object_data_types_operations import build_list_fields_by_module_and_type_request, build_list_fields_by_type_request +from ...operations._object_data_types_operations import ( + build_list_fields_by_module_and_type_request, + build_list_fields_by_type_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ObjectDataTypesOperations: """ .. warning:: @@ -43,48 +54,37 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_fields_by_module_and_type( - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - type_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.TypeFieldListResult]: + self, resource_group_name: str, automation_account_name: str, module_name: str, type_name: str, **kwargs: Any + ) -> AsyncIterable["_models.TypeField"]: """Retrieve a list of fields of a given type identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param type_name: The name of type. + :param type_name: The name of type. Required. :type type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either TypeFieldListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.TypeFieldListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either TypeField or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.TypeField] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.TypeFieldListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.TypeFieldListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_fields_by_module_and_type_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -92,7 +92,7 @@ def prepare_request(next_link=None): type_name=type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_fields_by_module_and_type.metadata['url'], + template_url=self.list_fields_by_module_and_type.metadata["url"], headers=_headers, params=_params, ) @@ -100,18 +100,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_fields_by_module_and_type_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - module_name=module_name, - type_name=type_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -127,10 +116,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -141,57 +128,46 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_fields_by_module_and_type.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/objectDataTypes/{typeName}/fields"} # type: ignore + list_fields_by_module_and_type.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/objectDataTypes/{typeName}/fields"} # type: ignore @distributed_trace def list_fields_by_type( - self, - resource_group_name: str, - automation_account_name: str, - type_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.TypeFieldListResult]: + self, resource_group_name: str, automation_account_name: str, type_name: str, **kwargs: Any + ) -> AsyncIterable["_models.TypeField"]: """Retrieve a list of fields of a given type across all accessible modules. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param type_name: The name of type. + :param type_name: The name of type. Required. :type type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either TypeFieldListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.TypeFieldListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either TypeField or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.TypeField] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.TypeFieldListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.TypeFieldListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_fields_by_type_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, type_name=type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_fields_by_type.metadata['url'], + template_url=self.list_fields_by_type.metadata["url"], headers=_headers, params=_params, ) @@ -199,17 +175,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_fields_by_type_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - type_name=type_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -225,10 +191,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -239,8 +203,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_fields_by_type.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/objectDataTypes/{typeName}/fields"} # type: ignore + list_fields_by_type.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/objectDataTypes/{typeName}/fields"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_operations.py index e6c42b890f6c..639af2dbf318 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -21,9 +27,11 @@ from ..._vendor import _convert_request from ...operations._operations import build_list_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Operations: """ .. warning:: @@ -43,39 +51,30 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> AsyncIterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: """Lists all of the available Automation REST API operations. - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Operation or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Operation] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_request( api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -83,13 +82,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -105,10 +98,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -119,8 +110,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.Automation/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.Automation/operations"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_patch.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_patch.py index 0ad201a8c586..f7dd32510333 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_patch.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_patch.py @@ -10,6 +10,7 @@ __all__: List[str] = [] # Add all objects you want publicly available to users at this package level + def patch_sdk(): """Do not remove from this file. diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_private_endpoint_connections_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_private_endpoint_connections_operations.py index 1a9942a74962..1edbb23d9d9f 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_private_endpoint_connections_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_private_endpoint_connections_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,11 +28,18 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._private_endpoint_connections_operations import build_create_or_update_request_initial, build_delete_request_initial, build_get_request, build_list_by_automation_account_request +from ...operations._private_endpoint_connections_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateEndpointConnectionsOperations: """ .. warning:: @@ -46,49 +59,41 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.PrivateEndpointConnectionListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.PrivateEndpointConnection"]: """List all private endpoint connections on a Automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) + :return: An iterator like instance of either PrivateEndpointConnection or the result of + cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.PrivateEndpointConnection] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -96,16 +101,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -121,10 +117,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -134,11 +128,9 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections"} # type: ignore @distributed_trace_async async def get( @@ -150,39 +142,33 @@ async def get( ) -> _models.PrivateEndpointConnection: """Gets a private endpoint connection. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param private_endpoint_connection_name: The name of the private endpoint connection. + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. :type private_endpoint_connection_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.automation.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, private_endpoint_connection_name=private_endpoint_connection_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -190,57 +176,60 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _create_or_update_initial( self, resource_group_name: str, automation_account_name: str, private_endpoint_connection_name: str, - parameters: _models.PrivateEndpointConnection, + parameters: Union[_models.PrivateEndpointConnection, IO], **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - _json = self._serialize.body(parameters, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PrivateEndpointConnection") - request = build_create_or_update_request_initial( - subscription_id=self._config.subscription_id, + request = build_create_or_update_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, private_endpoint_connection_name=private_endpoint_connection_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -248,50 +237,51 @@ async def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - @distributed_trace_async + @overload async def begin_create_or_update( self, resource_group_name: str, automation_account_name: str, private_endpoint_connection_name: str, parameters: _models.PrivateEndpointConnection, + *, + content_type: str = "application/json", **kwargs: Any ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: """Approve or reject a private endpoint connection with a given name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param private_endpoint_connection_name: The name of the private endpoint connection. + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. :type private_endpoint_connection_name: str - :param parameters: + :param parameters: Required. :type parameters: ~azure.mgmt.automation.models.PrivateEndpointConnection - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -304,20 +294,93 @@ async def begin_create_or_update( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + private_endpoint_connection_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: + """Approve or reject a private endpoint connection with a given name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. + :type private_endpoint_connection_name: str + :param parameters: Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.PrivateEndpointConnection] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + private_endpoint_connection_name: str, + parameters: Union[_models.PrivateEndpointConnection, IO], + **kwargs: Any + ) -> AsyncLROPoller[_models.PrivateEndpointConnection]: + """Approve or reject a private endpoint connection with a given name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. + :type private_endpoint_connection_name: str + :param parameters: Is either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either PrivateEndpointConnection or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.automation.models.PrivateEndpointConnection] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -326,39 +389,35 @@ async def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore async def _delete_initial( # pylint: disable=inconsistent-return-statements self, @@ -367,25 +426,22 @@ async def _delete_initial( # pylint: disable=inconsistent-return-statements private_endpoint_connection_name: str, **kwargs: Any ) -> None: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, private_endpoint_connection_name=private_endpoint_connection_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -393,24 +449,23 @@ async def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202, 204]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace_async - async def begin_delete( # pylint: disable=inconsistent-return-statements + async def begin_delete( self, resource_group_name: str, automation_account_name: str, @@ -419,15 +474,12 @@ async def begin_delete( # pylint: disable=inconsistent-return-statements ) -> AsyncLROPoller[None]: """Deletes a private endpoint connection with a given name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param private_endpoint_connection_name: The name of the private endpoint connection. + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. :type private_endpoint_connection_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -438,53 +490,46 @@ async def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._delete_initial( # type: ignore resource_group_name=resource_group_name, automation_account_name=automation_account_name, private_endpoint_connection_name=private_endpoint_connection_name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_private_link_resources_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_private_link_resources_operations.py index 39791692e717..4d3081507178 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_private_link_resources_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_private_link_resources_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -21,9 +27,11 @@ from ..._vendor import _convert_request from ...operations._private_link_resources_operations import build_automation_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class PrivateLinkResourcesOperations: """ .. warning:: @@ -43,49 +51,40 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def automation( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.PrivateLinkResourceListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.PrivateLinkResource"]: """Gets the private link resources that need to be created for Automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateLinkResourceListResult or the result of - cls(response) + :return: An iterator like instance of either PrivateLinkResource or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.PrivateLinkResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.PrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_automation_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.automation.metadata['url'], + template_url=self.automation.metadata["url"], headers=_headers, params=_params, ) @@ -93,16 +92,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_automation_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -118,10 +108,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -131,8 +119,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - automation.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateLinkResources"} # type: ignore + automation.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateLinkResources"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_python2_package_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_python2_package_operations.py index eb2ea2a6f512..67929bfa50b4 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_python2_package_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_python2_package_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._python2_package_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._python2_package_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class Python2PackageOperations: """ .. warning:: @@ -44,50 +58,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - package_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, package_name: str, **kwargs: Any ) -> None: """Delete the python 2 package by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param package_name: The python package name. + :param package_name: The python package name. Required. :type package_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, package_name=package_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -95,10 +98,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,52 +111,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - package_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, package_name: str, **kwargs: Any ) -> _models.Module: """Retrieve the python 2 package identified by package name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param package_name: The python package name. + :param package_name: The python package name. Required. :type package_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, package_name=package_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +153,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -173,56 +163,120 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, package_name: str, parameters: _models.PythonPackageCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Module: """Create or Update the python 2 package identified by package name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param package_name: The name of python package. + :param package_name: The name of python package. Required. :type package_name: str - :param parameters: The create or update parameters for python package. + :param parameters: The create or update parameters for python package. Required. :type parameters: ~azure.mgmt.automation.models.PythonPackageCreateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 2 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: Union[_models.PythonPackageCreateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 2 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Is either a model type + or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - _json = self._serialize.body(parameters, 'PythonPackageCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PythonPackageCreateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -232,7 +286,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -240,10 +295,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -252,59 +306,123 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, package_name: str, parameters: _models.PythonPackageUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Module: """Update the python 2 package identified by package name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param package_name: The name of python package. + :param package_name: The name of python package. Required. :type package_name: str - :param parameters: The update parameters for python package. + :param parameters: The update parameters for python package. Required. :type parameters: ~azure.mgmt.automation.models.PythonPackageUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Update the python 2 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: Union[_models.PythonPackageUpdateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Update the python 2 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - _json = self._serialize.body(parameters, 'PythonPackageUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PythonPackageUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -314,7 +432,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -322,10 +441,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -333,56 +451,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.ModuleListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Module"]: """Retrieve a list of python 2 packages. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ModuleListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.ModuleListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Module or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Module] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ModuleListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ModuleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -390,16 +500,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -415,10 +516,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -429,8 +528,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_python3_package_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_python3_package_operations.py new file mode 100644 index 000000000000..d437167f5495 --- /dev/null +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_python3_package_operations.py @@ -0,0 +1,533 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.async_paging import AsyncItemPaged, AsyncList +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.pipeline.transport import AsyncHttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from ... import models as _models +from ..._vendor import _convert_request +from ...operations._python3_package_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) +from .._vendor import MixinABC + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class Python3PackageOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.automation.aio.AutomationClient`'s + :attr:`python3_package` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + async def delete( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, automation_account_name: str, package_name: str, **kwargs: Any + ) -> None: + """Delete the python 3 package by name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The python package name. Required. + :type package_name: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + + request = build_delete_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + package_name=package_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.delete.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) + + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}"} # type: ignore + + @distributed_trace_async + async def get( + self, resource_group_name: str, automation_account_name: str, package_name: str, **kwargs: Any + ) -> _models.Module: + """Retrieve the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The python package name. Required. + :type package_name: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] + + request = build_get_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + package_name=package_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.get.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Module", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}"} # type: ignore + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: _models.PythonPackageCreateParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageCreateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: Union[_models.PythonPackageCreateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Is either a model type + or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PythonPackageCreateParameters") + + request = build_create_or_update_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + package_name=package_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create_or_update.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if response.status_code == 200: + deserialized = self._deserialize("Module", pipeline_response) + + if response.status_code == 201: + deserialized = self._deserialize("Module", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}"} # type: ignore + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: _models.PythonPackageUpdateParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageUpdateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: Union[_models.PythonPackageUpdateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PythonPackageUpdateParameters") + + request = build_update_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + package_name=package_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.update.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Module", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}"} # type: ignore + + @distributed_trace + def list_by_automation_account( + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Module"]: + """Retrieve a list of python 3 packages. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: An iterator like instance of either Module or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Module] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ModuleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + request = build_list_by_automation_account_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + else: + request = HttpRequest("GET", next_link) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" + return request + + async def extract_data(pipeline_response): + deserialized = self._deserialize("ModuleListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) + return deserialized.next_link or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + request = prepare_request(next_link) + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_runbook_draft_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_runbook_draft_operations.py index 7ae8c54fa591..8c8c10d16977 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_runbook_draft_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_runbook_draft_operations.py @@ -6,9 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, cast - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -20,11 +26,18 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._runbook_draft_operations import build_get_content_request, build_get_request, build_replace_content_request_initial, build_undo_edit_request +from ...operations._runbook_draft_operations import ( + build_get_content_request, + build_get_request, + build_replace_content_request, + build_undo_edit_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class RunbookDraftOperations: """ .. warning:: @@ -44,50 +57,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get_content( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any - ) -> IO: + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any + ) -> AsyncIterator[bytes]: """Retrieve the content of runbook draft identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: IO, or the result of cls(response) - :rtype: IO - :raises: ~azure.core.exceptions.HttpResponseError + :return: Async iterator of the response bytes or the result of cls(response) + :rtype: AsyncIterator[bytes] + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[IO] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[AsyncIterator[bytes]] - request = build_get_content_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_content.metadata['url'], + template_url=self.get_content.metadata["url"], headers=_headers, params=_params, ) @@ -95,57 +97,53 @@ async def get_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=True, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('IO', pipeline_response) + deserialized = response.stream_download(self._client._pipeline) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore + get_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore - - async def _replace_content_initial( + async def _replace_content_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, automation_account_name: str, runbook_name: str, - runbook_content: str, + runbook_content: IO, **kwargs: Any - ) -> Optional[IO]: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + ) -> None: + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "text/powershell")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[Optional[IO]] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] _content = runbook_content - request = build_replace_content_request_initial( - subscription_id=self._config.subscription_id, + request = build_replace_content_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, content=_content, - template_url=self._replace_content_initial.metadata['url'], + template_url=self._replace_content_initial.metadata["url"], headers=_headers, params=_params, ) @@ -153,32 +151,24 @@ async def _replace_content_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=True, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = None response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: - response_headers['location']=self._deserialize('str', response.headers.get('location')) - + response_headers["location"] = self._deserialize("str", response.headers.get("location")) if cls: - return cls(pipeline_response, deserialized, response_headers) - - return deserialized - - _replace_content_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore + return cls(pipeline_response, None, response_headers) + _replace_content_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore @distributed_trace_async async def begin_replace_content( @@ -186,22 +176,19 @@ async def begin_replace_content( resource_group_name: str, automation_account_name: str, runbook_name: str, - runbook_content: str, + runbook_content: IO, **kwargs: Any - ) -> AsyncLROPoller[IO]: + ) -> AsyncLROPoller[None]: """Replaces the runbook draft content. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :param runbook_content: The runbook draft content. - :type runbook_content: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :param runbook_content: The runbook draft content. Required. + :type runbook_content: IO :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -210,22 +197,19 @@ async def begin_replace_content( :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. - :return: An instance of AsyncLROPoller that returns either IO or the result of cls(response) - :rtype: ~azure.core.polling.AsyncLROPoller[IO] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) + :rtype: ~azure.core.polling.AsyncLROPoller[None] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "text/powershell")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[IO] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._replace_content_initial( # type: ignore resource_group_name=resource_group_name, @@ -234,83 +218,69 @@ async def begin_replace_content( runbook_content=runbook_content, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): - deserialized = response.stream_download(self._client._pipeline) + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: - return cls(pipeline_response, deserialized, {}) - return deserialized - + return cls(pipeline_response, None, {}) if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast( + AsyncPollingMethod, AsyncARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_replace_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore + begin_replace_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> _models.RunbookDraft: """Retrieve the runbook draft identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: RunbookDraft, or the result of cls(response) + :return: RunbookDraft or the result of cls(response) :rtype: ~azure.mgmt.automation.models.RunbookDraft - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.RunbookDraft] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.RunbookDraft] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -318,10 +288,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -329,59 +298,48 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('RunbookDraft', pipeline_response) + deserialized = self._deserialize("RunbookDraft", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft"} # type: ignore @distributed_trace_async - async def undo_edit( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any - ) -> _models.RunbookDraftUndoEditResult: + async def undo_edit( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any + ) -> None: """Undo draft edit to last known published state identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: RunbookDraftUndoEditResult, or the result of cls(response) - :rtype: ~azure.mgmt.automation.models.RunbookDraftUndoEditResult - :raises: ~azure.core.exceptions.HttpResponseError + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.RunbookDraftUndoEditResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_undo_edit_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.undo_edit.metadata['url'], + template_url=self.undo_edit.metadata["url"], headers=_headers, params=_params, ) @@ -389,10 +347,9 @@ async def undo_edit( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -400,12 +357,7 @@ async def undo_edit( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('RunbookDraftUndoEditResult', pipeline_response) - if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized - - undo_edit.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/undoEdit"} # type: ignore + return cls(pipeline_response, None, {}) + undo_edit.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/undoEdit"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_runbook_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_runbook_operations.py index fcfcf3428727..63750db84413 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_runbook_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_runbook_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast +from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -22,11 +28,21 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._runbook_operations import build_create_or_update_request, build_delete_request, build_get_content_request, build_get_request, build_list_by_automation_account_request, build_publish_request_initial, build_update_request +from ...operations._runbook_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_content_request, + build_get_request, + build_list_by_automation_account_request, + build_publish_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class RunbookOperations: """ .. warning:: @@ -46,33 +62,25 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - async def _publish_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_publish_request_initial( - subscription_id=self._config.subscription_id, + request = build_publish_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._publish_initial.metadata['url'], + template_url=self._publish_initial.metadata["url"], headers=_headers, params=_params, ) @@ -80,45 +88,36 @@ async def _publish_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - response_headers['location']=self._deserialize('str', response.headers.get('location')) - + response_headers["location"] = self._deserialize("str", response.headers.get("location")) if cls: return cls(pipeline_response, None, response_headers) - _publish_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish"} # type: ignore - + _publish_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish"} # type: ignore @distributed_trace_async - async def begin_publish( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + async def begin_publish( + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> AsyncLROPoller[None]: """Publish runbook draft. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The parameters supplied to the publish runbook operation. + :param runbook_name: The parameters supplied to the publish runbook operation. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for @@ -129,100 +128,83 @@ async def begin_publish( # pylint: disable=inconsistent-return-statements Retry-After header is present. :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = await self._publish_initial( # type: ignore resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling( - lro_delay, - - - **kwargs - )) # type: AsyncPollingMethod - elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: polling_method = polling + polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_publish.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish"} # type: ignore + begin_publish.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish"} # type: ignore @distributed_trace_async async def get_content( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any - ) -> IO: + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any + ) -> AsyncIterator[bytes]: """Retrieve the content of runbook identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: IO, or the result of cls(response) - :rtype: IO - :raises: ~azure.core.exceptions.HttpResponseError + :return: Async iterator of the response bytes or the result of cls(response) + :rtype: AsyncIterator[bytes] + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[IO] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[AsyncIterator[bytes]] - request = build_get_content_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_content.metadata['url'], + template_url=self.get_content.metadata["url"], headers=_headers, params=_params, ) @@ -230,69 +212,57 @@ async def get_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=True, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('IO', pipeline_response) + deserialized = response.stream_download(self._client._pipeline) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/content"} # type: ignore - + get_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/content"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> _models.Runbook: """Retrieve the runbook identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Runbook, or the result of cls(response) + :return: Runbook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Runbook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Runbook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Runbook] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -300,10 +270,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -311,67 +280,133 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Runbook', pipeline_response) + deserialized = self._deserialize("Runbook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, runbook_name: str, parameters: _models.RunbookCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Runbook: """Create the runbook identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str :param parameters: The create or update parameters for runbook. Provide either content link for - a published runbook or draft, not both. + a published runbook or draft, not both. Required. :type parameters: ~azure.mgmt.automation.models.RunbookCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Runbook, or the result of cls(response) + :return: Runbook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Runbook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Runbook: + """Create the runbook identified by runbook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The runbook name. Required. + :type runbook_name: str + :param parameters: The create or update parameters for runbook. Provide either content link for + a published runbook or draft, not both. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Runbook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Runbook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: Union[_models.RunbookCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Runbook: + """Create the runbook identified by runbook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The runbook name. Required. + :type runbook_name: str + :param parameters: The create or update parameters for runbook. Provide either content link for + a published runbook or draft, not both. Is either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.RunbookCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Runbook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Runbook + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Runbook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Runbook] - _json = self._serialize.body(parameters, 'RunbookCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "RunbookCreateOrUpdateParameters") request = build_create_or_update_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -379,10 +414,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -391,69 +425,134 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Runbook', pipeline_response) + deserialized = self._deserialize("Runbook", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Runbook', pipeline_response) + deserialized = self._deserialize("Runbook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, runbook_name: str, parameters: _models.RunbookUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Runbook: """Update the runbook identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :param parameters: The update parameters for runbook. + :param parameters: The update parameters for runbook. Required. :type parameters: ~azure.mgmt.automation.models.RunbookUpdateParameters - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Runbook, or the result of cls(response) + :return: Runbook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Runbook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Runbook: + """Update the runbook identified by runbook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The runbook name. Required. + :type runbook_name: str + :param parameters: The update parameters for runbook. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Runbook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Runbook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: Union[_models.RunbookUpdateParameters, IO], + **kwargs: Any + ) -> _models.Runbook: + """Update the runbook identified by runbook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The runbook name. Required. + :type runbook_name: str + :param parameters: The update parameters for runbook. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.automation.models.RunbookUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Runbook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Runbook + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Runbook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Runbook] - _json = self._serialize.body(parameters, 'RunbookUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "RunbookUpdateParameters") request = build_update_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -461,10 +560,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -472,59 +570,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Runbook', pipeline_response) + deserialized = self._deserialize("Runbook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: """Delete the runbook by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -532,10 +619,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -546,50 +632,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.RunbookListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Runbook"]: """Retrieve a list of runbooks. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either RunbookListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.RunbookListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Runbook or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Runbook] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.RunbookListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.RunbookListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -597,16 +674,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -622,10 +690,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -636,8 +702,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_schedule_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_schedule_operations.py index e0d338c22709..f2d259d19337 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_schedule_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_schedule_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._schedule_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._schedule_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class ScheduleOperations: """ .. warning:: @@ -44,47 +58,113 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, schedule_name: str, parameters: _models.ScheduleCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> Optional[_models.Schedule]: """Create a schedule. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param schedule_name: The schedule name. + :param schedule_name: The schedule name. Required. :type schedule_name: str :param parameters: The parameters supplied to the create or update schedule operation. + Required. :type parameters: ~azure.mgmt.automation.models.ScheduleCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Schedule, or the result of cls(response) + :return: Schedule or None or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Schedule or None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + schedule_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> Optional[_models.Schedule]: + """Create a schedule. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param schedule_name: The schedule name. Required. + :type schedule_name: str + :param parameters: The parameters supplied to the create or update schedule operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Schedule or None or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Schedule or None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + schedule_name: str, + parameters: Union[_models.ScheduleCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> Optional[_models.Schedule]: + """Create a schedule. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param schedule_name: The schedule name. Required. + :type schedule_name: str + :param parameters: The parameters supplied to the create or update schedule operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ScheduleCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Schedule or None or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Schedule or None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.Schedule]] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.Schedule]] - _json = self._serialize.body(parameters, 'ScheduleCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ScheduleCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -94,7 +174,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -102,10 +183,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201, 409]: @@ -115,59 +195,123 @@ async def create_or_update( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('Schedule', pipeline_response) + deserialized = self._deserialize("Schedule", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Schedule', pipeline_response) + deserialized = self._deserialize("Schedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, schedule_name: str, parameters: _models.ScheduleUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Schedule: """Update the schedule identified by schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param schedule_name: The schedule name. + :param schedule_name: The schedule name. Required. :type schedule_name: str - :param parameters: The parameters supplied to the update schedule operation. + :param parameters: The parameters supplied to the update schedule operation. Required. :type parameters: ~azure.mgmt.automation.models.ScheduleUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Schedule, or the result of cls(response) + :return: Schedule or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Schedule - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + schedule_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Schedule: + """Update the schedule identified by schedule name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param schedule_name: The schedule name. Required. + :type schedule_name: str + :param parameters: The parameters supplied to the update schedule operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Schedule or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Schedule + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + schedule_name: str, + parameters: Union[_models.ScheduleUpdateParameters, IO], + **kwargs: Any + ) -> _models.Schedule: + """Update the schedule identified by schedule name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param schedule_name: The schedule name. Required. + :type schedule_name: str + :param parameters: The parameters supplied to the update schedule operation. Is either a model + type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ScheduleUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Schedule or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Schedule + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Schedule] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Schedule] - _json = self._serialize.body(parameters, 'ScheduleUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ScheduleUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -177,7 +321,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -185,10 +330,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -196,59 +340,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Schedule', pipeline_response) + deserialized = self._deserialize("Schedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - schedule_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, schedule_name: str, **kwargs: Any ) -> _models.Schedule: """Retrieve the schedule identified by schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param schedule_name: The schedule name. + :param schedule_name: The schedule name. Required. :type schedule_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Schedule, or the result of cls(response) + :return: Schedule or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Schedule - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Schedule] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Schedule] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, schedule_name=schedule_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -256,10 +389,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -267,59 +399,48 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Schedule', pipeline_response) + deserialized = self._deserialize("Schedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - schedule_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, schedule_name: str, **kwargs: Any ) -> None: """Delete the schedule identified by schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param schedule_name: The schedule name. + :param schedule_name: The schedule name. Required. :type schedule_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, schedule_name=schedule_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -327,10 +448,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -341,50 +461,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.ScheduleListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Schedule"]: """Retrieve a list of schedules. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ScheduleListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.ScheduleListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Schedule or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Schedule] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ScheduleListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ScheduleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -392,16 +503,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -417,10 +519,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -431,8 +531,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configuration_machine_runs_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configuration_machine_runs_operations.py index c068bf2c255a..51f47114f568 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configuration_machine_runs_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configuration_machine_runs_operations.py @@ -8,7 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -18,11 +24,16 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._software_update_configuration_machine_runs_operations import build_get_by_id_request, build_list_request +from ...operations._software_update_configuration_machine_runs_operations import ( + build_get_by_id_request, + build_list_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SoftwareUpdateConfigurationMachineRunsOperations: """ .. warning:: @@ -42,7 +53,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get_by_id( self, @@ -54,43 +64,37 @@ async def get_by_id( ) -> _models.SoftwareUpdateConfigurationMachineRun: """Get a single software update configuration machine run by Id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_machine_run_id: The Id of the software update - configuration machine run. + configuration machine run. Required. :type software_update_configuration_machine_run_id: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationMachineRun, or the result of cls(response) + :return: SoftwareUpdateConfigurationMachineRun or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationMachineRun - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationMachineRun] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationMachineRun] - request = build_get_by_id_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_machine_run_id=software_update_configuration_machine_run_id, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_by_id.metadata['url'], + api_version=api_version, + template_url=self.get_by_id.metadata["url"], headers=_headers, params=_params, ) @@ -98,10 +102,9 @@ async def get_by_id( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -109,15 +112,14 @@ async def get_by_id( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationMachineRun', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationMachineRun", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_by_id.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns/{softwareUpdateConfigurationMachineRunId}"} # type: ignore - + get_by_id.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns/{softwareUpdateConfigurationMachineRunId}"} # type: ignore @distributed_trace_async async def list( @@ -132,9 +134,9 @@ async def list( ) -> _models.SoftwareUpdateConfigurationMachineRunListResult: """Return list of software update configuration machine runs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str @@ -147,36 +149,30 @@ async def list( :param top: Maximum number of entries returned in the results collection. Default value is None. :type top: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationMachineRunListResult, or the result of cls(response) + :return: SoftwareUpdateConfigurationMachineRunListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationMachineRunListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationMachineRunListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationMachineRunListResult] - request = build_list_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, filter=filter, skip=skip, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -184,10 +180,9 @@ async def list( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -195,12 +190,11 @@ async def list( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationMachineRunListResult', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationMachineRunListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns"} # type: ignore - + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configuration_runs_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configuration_runs_operations.py index c403ab0be327..88a30c9519d1 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configuration_runs_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configuration_runs_operations.py @@ -8,7 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,9 +26,11 @@ from ..._vendor import _convert_request from ...operations._software_update_configuration_runs_operations import build_get_by_id_request, build_list_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SoftwareUpdateConfigurationRunsOperations: """ .. warning:: @@ -42,7 +50,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get_by_id( self, @@ -54,42 +61,37 @@ async def get_by_id( ) -> _models.SoftwareUpdateConfigurationRun: """Get a single software update configuration Run by Id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_run_id: The Id of the software update configuration run. + Required. :type software_update_configuration_run_id: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationRun, or the result of cls(response) + :return: SoftwareUpdateConfigurationRun or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationRun - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationRun] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationRun] - request = build_get_by_id_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_run_id=software_update_configuration_run_id, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_by_id.metadata['url'], + api_version=api_version, + template_url=self.get_by_id.metadata["url"], headers=_headers, params=_params, ) @@ -97,10 +99,9 @@ async def get_by_id( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -108,15 +109,14 @@ async def get_by_id( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationRun', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationRun", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_by_id.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns/{softwareUpdateConfigurationRunId}"} # type: ignore - + get_by_id.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns/{softwareUpdateConfigurationRunId}"} # type: ignore @distributed_trace_async async def list( @@ -131,9 +131,9 @@ async def list( ) -> _models.SoftwareUpdateConfigurationRunListResult: """Return list of software update configuration runs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str @@ -146,36 +146,30 @@ async def list( :param top: Maximum number of entries returned in the results collection. Default value is None. :type top: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationRunListResult, or the result of cls(response) + :return: SoftwareUpdateConfigurationRunListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationRunListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationRunListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationRunListResult] - request = build_list_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, filter=filter, skip=skip, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -183,10 +177,9 @@ async def list( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -194,12 +187,11 @@ async def list( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationRunListResult', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationRunListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns"} # type: ignore - + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configurations_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configurations_operations.py index 129f7a7afc07..f4dc27a5fa67 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configurations_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_software_update_configurations_operations.py @@ -6,9 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Optional, TypeVar - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -18,11 +24,18 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._software_update_configurations_operations import build_create_request, build_delete_request, build_get_by_name_request, build_list_request +from ...operations._software_update_configurations_operations import ( + build_create_request, + build_delete_request, + build_get_by_name_request, + build_list_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SoftwareUpdateConfigurationsOperations: """ .. warning:: @@ -42,8 +55,7 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async + @overload async def create( self, resource_group_name: str, @@ -51,53 +63,126 @@ async def create( software_update_configuration_name: str, parameters: _models.SoftwareUpdateConfiguration, client_request_id: Optional[str] = None, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.SoftwareUpdateConfiguration: """Create a new software update configuration with the name given in the URI. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_name: The name of the software update configuration to be - created. + created. Required. :type software_update_configuration_name: str - :param parameters: Request body. + :param parameters: Request body. Required. :type parameters: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SoftwareUpdateConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create( + self, + resource_group_name: str, + automation_account_name: str, + software_update_configuration_name: str, + parameters: IO, + client_request_id: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SoftwareUpdateConfiguration: + """Create a new software update configuration with the name given in the URI. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param software_update_configuration_name: The name of the software update configuration to be + created. Required. + :type software_update_configuration_name: str + :param parameters: Request body. Required. + :type parameters: IO + :param client_request_id: Identifies this specific client request. Default value is None. + :type client_request_id: str + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SoftwareUpdateConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + automation_account_name: str, + software_update_configuration_name: str, + parameters: Union[_models.SoftwareUpdateConfiguration, IO], + client_request_id: Optional[str] = None, + **kwargs: Any + ) -> _models.SoftwareUpdateConfiguration: + """Create a new software update configuration with the name given in the URI. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param software_update_configuration_name: The name of the software update configuration to be + created. Required. + :type software_update_configuration_name: str + :param parameters: Request body. Is either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration or IO + :param client_request_id: Identifies this specific client request. Default value is None. + :type client_request_id: str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfiguration, or the result of cls(response) + :return: SoftwareUpdateConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfiguration] - _json = self._serialize.body(parameters, 'SoftwareUpdateConfiguration') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SoftwareUpdateConfiguration") request = build_create_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_name=software_update_configuration_name, + subscription_id=self._config.subscription_id, + client_request_id=client_request_id, api_version=api_version, content_type=content_type, json=_json, - client_request_id=client_request_id, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -105,10 +190,9 @@ async def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -117,18 +201,17 @@ async def create( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('SoftwareUpdateConfiguration', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfiguration", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('SoftwareUpdateConfiguration', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore @distributed_trace_async async def get_by_name( @@ -141,43 +224,37 @@ async def get_by_name( ) -> _models.SoftwareUpdateConfiguration: """Get a single software update configuration by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_name: The name of the software update configuration to be - created. + created. Required. :type software_update_configuration_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfiguration, or the result of cls(response) + :return: SoftwareUpdateConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfiguration] - request = build_get_by_name_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_name=software_update_configuration_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_by_name.metadata['url'], + api_version=api_version, + template_url=self.get_by_name.metadata["url"], headers=_headers, params=_params, ) @@ -185,10 +262,9 @@ async def get_by_name( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -196,15 +272,14 @@ async def get_by_name( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfiguration', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_by_name.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore - + get_by_name.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -217,43 +292,37 @@ async def delete( # pylint: disable=inconsistent-return-statements ) -> None: """delete a specific software update configuration. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_name: The name of the software update configuration to be - created. + created. Required. :type software_update_configuration_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_name=software_update_configuration_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.delete.metadata['url'], + api_version=api_version, + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -261,10 +330,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -275,8 +343,7 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore @distributed_trace_async async def list( @@ -289,42 +356,36 @@ async def list( ) -> _models.SoftwareUpdateConfigurationListResult: """Get all software update configurations for the account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationListResult, or the result of cls(response) + :return: SoftwareUpdateConfigurationListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationListResult] - request = build_list_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, filter=filter, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -332,10 +393,9 @@ async def list( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -343,12 +403,11 @@ async def list( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationListResult', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations"} # type: ignore - + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_operations.py index 921fc83997a7..09a3df2c150d 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._source_control_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._source_control_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SourceControlOperations: """ .. warning:: @@ -44,47 +58,113 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, source_control_name: str, parameters: _models.SourceControlCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.SourceControl: """Create a source control. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str :param parameters: The parameters supplied to the create or update source control operation. + Required. :type parameters: ~azure.mgmt.automation.models.SourceControlCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControl or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControl + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SourceControl: + """Create a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param parameters: The parameters supplied to the create or update source control operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControl or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControl + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + parameters: Union[_models.SourceControlCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.SourceControl: + """Create a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param parameters: The parameters supplied to the create or update source control operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.SourceControlCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControl, or the result of cls(response) + :return: SourceControl or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControl - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControl] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControl] - _json = self._serialize.body(parameters, 'SourceControlCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SourceControlCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -94,7 +174,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -102,10 +183,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -114,59 +194,123 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('SourceControl', pipeline_response) + deserialized = self._deserialize("SourceControl", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('SourceControl', pipeline_response) + deserialized = self._deserialize("SourceControl", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, source_control_name: str, parameters: _models.SourceControlUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.SourceControl: """Update a source control. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param parameters: The parameters supplied to the update source control operation. + :param parameters: The parameters supplied to the update source control operation. Required. :type parameters: ~azure.mgmt.automation.models.SourceControlUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControl or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControl + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SourceControl: + """Update a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param parameters: The parameters supplied to the update source control operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControl, or the result of cls(response) + :return: SourceControl or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControl - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + parameters: Union[_models.SourceControlUpdateParameters, IO], + **kwargs: Any + ) -> _models.SourceControl: + """Update a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param parameters: The parameters supplied to the update source control operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.SourceControlUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControl or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControl + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControl] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControl] - _json = self._serialize.body(parameters, 'SourceControlUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SourceControlUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -176,7 +320,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -184,10 +329,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -195,59 +339,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControl', pipeline_response) + deserialized = self._deserialize("SourceControl", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - source_control_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, source_control_name: str, **kwargs: Any ) -> None: """Delete the source control. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The name of source control. + :param source_control_name: The name of source control. Required. :type source_control_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, source_control_name=source_control_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -255,10 +388,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -269,52 +401,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - source_control_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, source_control_name: str, **kwargs: Any ) -> _models.SourceControl: """Retrieve the source control identified by source control name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The name of source control. + :param source_control_name: The name of source control. Required. :type source_control_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControl, or the result of cls(response) + :return: SourceControl or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControl - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControl] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControl] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, source_control_name=source_control_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -322,10 +443,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -333,62 +453,51 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControl', pipeline_response) + deserialized = self._deserialize("SourceControl", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> AsyncIterable[_models.SourceControlListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.SourceControl"]: """Retrieve a list of source controls. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SourceControlListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.SourceControlListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either SourceControl or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.SourceControl] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -396,17 +505,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -422,10 +521,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -436,8 +533,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_sync_job_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_sync_job_operations.py index 260e30922917..0c15a7e5d7ed 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_sync_job_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_sync_job_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,17 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._source_control_sync_job_operations import build_create_request, build_get_request, build_list_by_automation_account_request +from ...operations._source_control_sync_job_operations import ( + build_create_request, + build_get_request, + build_list_by_automation_account_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SourceControlSyncJobOperations: """ .. warning:: @@ -44,8 +56,7 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async + @overload async def create( self, resource_group_name: str, @@ -53,41 +64,114 @@ async def create( source_control_name: str, source_control_sync_job_id: str, parameters: _models.SourceControlSyncJobCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.SourceControlSyncJob: """Creates the sync job for a source control. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param source_control_sync_job_id: The source control sync job id. + :param source_control_sync_job_id: The source control sync job id. Required. :type source_control_sync_job_id: str :param parameters: The parameters supplied to the create source control sync job operation. + Required. :type parameters: ~azure.mgmt.automation.models.SourceControlSyncJobCreateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControlSyncJob, or the result of cls(response) + :return: SourceControlSyncJob or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControlSyncJob - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def create( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + source_control_sync_job_id: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SourceControlSyncJob: + """Creates the sync job for a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param source_control_sync_job_id: The source control sync job id. Required. + :type source_control_sync_job_id: str + :param parameters: The parameters supplied to the create source control sync job operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControlSyncJob or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControlSyncJob + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + source_control_sync_job_id: str, + parameters: Union[_models.SourceControlSyncJobCreateParameters, IO], + **kwargs: Any + ) -> _models.SourceControlSyncJob: + """Creates the sync job for a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param source_control_sync_job_id: The source control sync job id. Required. + :type source_control_sync_job_id: str + :param parameters: The parameters supplied to the create source control sync job operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.SourceControlSyncJobCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControlSyncJob or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControlSyncJob + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJob] - _json = self._serialize.body(parameters, 'SourceControlSyncJobCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SourceControlSyncJobCreateParameters") request = build_create_request( resource_group_name=resource_group_name, @@ -98,7 +182,8 @@ async def create( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -106,10 +191,9 @@ async def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -117,15 +201,14 @@ async def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControlSyncJob', pipeline_response) + deserialized = self._deserialize("SourceControlSyncJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}"} # type: ignore @distributed_trace_async async def get( @@ -138,34 +221,28 @@ async def get( ) -> _models.SourceControlSyncJobById: """Retrieve the source control sync job identified by job id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param source_control_sync_job_id: The source control sync job id. + :param source_control_sync_job_id: The source control sync job id. Required. :type source_control_sync_job_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControlSyncJobById, or the result of cls(response) + :return: SourceControlSyncJobById or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControlSyncJobById - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJobById] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJobById] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -173,7 +250,7 @@ async def get( source_control_sync_job_id=source_control_sync_job_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -181,10 +258,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -192,15 +268,14 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControlSyncJobById', pipeline_response) + deserialized = self._deserialize("SourceControlSyncJobById", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}"} # type: ignore @distributed_trace def list_by_automation_account( @@ -210,48 +285,44 @@ def list_by_automation_account( source_control_name: str, filter: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.SourceControlSyncJobListResult]: + ) -> AsyncIterable["_models.SourceControlSyncJob"]: """Retrieve a list of source control sync jobs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SourceControlSyncJobListResult or the result of + :return: An iterator like instance of either SourceControlSyncJob or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.SourceControlSyncJobListResult] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.SourceControlSyncJob] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJobListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJobListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, source_control_name=source_control_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -259,18 +330,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - source_control_name=source_control_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -286,10 +346,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -300,8 +358,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_sync_job_streams_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_sync_job_streams_operations.py index dcb52ca73e4a..dc8d71408c96 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_sync_job_streams_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_source_control_sync_job_streams_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -22,9 +28,11 @@ from ..._vendor import _convert_request from ...operations._source_control_sync_job_streams_operations import build_get_request, build_list_by_sync_job_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class SourceControlSyncJobStreamsOperations: """ .. warning:: @@ -44,7 +52,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_sync_job( self, @@ -54,51 +61,47 @@ def list_by_sync_job( source_control_sync_job_id: str, filter: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.SourceControlSyncJobStreamsListBySyncJob]: + ) -> AsyncIterable["_models.SourceControlSyncJobStream"]: """Retrieve a list of sync job streams identified by sync job id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param source_control_sync_job_id: The source control sync job id. + :param source_control_sync_job_id: The source control sync job id. Required. :type source_control_sync_job_id: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SourceControlSyncJobStreamsListBySyncJob or the - result of cls(response) + :return: An iterator like instance of either SourceControlSyncJobStream or the result of + cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.SourceControlSyncJobStreamsListBySyncJob] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.SourceControlSyncJobStream] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJobStreamsListBySyncJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJobStreamsListBySyncJob] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_sync_job_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, source_control_name=source_control_name, source_control_sync_job_id=source_control_sync_job_id, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_sync_job.metadata['url'], + api_version=api_version, + template_url=self.list_by_sync_job.metadata["url"], headers=_headers, params=_params, ) @@ -106,19 +109,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_sync_job_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - source_control_name=source_control_name, - source_control_sync_job_id=source_control_sync_job_id, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -134,10 +125,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -148,11 +137,9 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_sync_job.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams"} # type: ignore + list_by_sync_job.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams"} # type: ignore @distributed_trace_async async def get( @@ -166,36 +153,30 @@ async def get( ) -> _models.SourceControlSyncJobStreamById: """Retrieve a sync job stream identified by stream id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param source_control_sync_job_id: The source control sync job id. + :param source_control_sync_job_id: The source control sync job id. Required. :type source_control_sync_job_id: str - :param stream_id: The id of the sync job stream. + :param stream_id: The id of the sync job stream. Required. :type stream_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControlSyncJobStreamById, or the result of cls(response) + :return: SourceControlSyncJobStreamById or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControlSyncJobStreamById - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJobStreamById] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJobStreamById] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -204,7 +185,7 @@ async def get( stream_id=stream_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -212,10 +193,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -223,12 +203,11 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControlSyncJobStreamById', pipeline_response) + deserialized = self._deserialize("SourceControlSyncJobStreamById", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams/{streamId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams/{streamId}"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_statistics_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_statistics_operations.py index 6078ff670dec..7e622257cf88 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_statistics_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_statistics_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -21,9 +27,11 @@ from ..._vendor import _convert_request from ...operations._statistics_operations import build_list_by_automation_account_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class StatisticsOperations: """ .. warning:: @@ -43,53 +51,42 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> AsyncIterable[_models.StatisticsListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.Statistics"]: """Retrieve the statistics for the account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either StatisticsListResult or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.StatisticsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Statistics or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Statistics] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.StatisticsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.StatisticsListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -97,17 +94,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -123,10 +110,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -137,8 +122,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/statistics"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/statistics"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_test_job_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_test_job_operations.py index a54dac0cb259..19cb3909f800 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_test_job_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_test_job_operations.py @@ -6,9 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Optional, TypeVar - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -18,11 +24,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._test_job_operations import build_create_request, build_get_request, build_resume_request, build_stop_request, build_suspend_request +from ...operations._test_job_operations import ( + build_create_request, + build_get_request, + build_resume_request, + build_stop_request, + build_suspend_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class TestJobOperations: """ .. warning:: @@ -42,57 +56,122 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async + @overload async def create( self, resource_group_name: str, automation_account_name: str, runbook_name: str, parameters: _models.TestJobCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.TestJob: """Create a test job of the runbook. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The parameters supplied to the create test job operation. + :param runbook_name: The parameters supplied to the create test job operation. Required. :type runbook_name: str - :param parameters: The parameters supplied to the create test job operation. + :param parameters: The parameters supplied to the create test job operation. Required. :type parameters: ~azure.mgmt.automation.models.TestJobCreateParameters - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: TestJob, or the result of cls(response) + :return: TestJob or the result of cls(response) :rtype: ~azure.mgmt.automation.models.TestJob - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def create( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.TestJob: + """Create a test job of the runbook. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The parameters supplied to the create test job operation. Required. + :type runbook_name: str + :param parameters: The parameters supplied to the create test job operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: TestJob or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.TestJob + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: Union[_models.TestJobCreateParameters, IO], + **kwargs: Any + ) -> _models.TestJob: + """Create a test job of the runbook. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The parameters supplied to the create test job operation. Required. + :type runbook_name: str + :param parameters: The parameters supplied to the create test job operation. Is either a model + type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.TestJobCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: TestJob or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.TestJob + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.TestJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.TestJob] - _json = self._serialize.body(parameters, 'TestJobCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "TestJobCreateParameters") request = build_create_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -100,10 +179,9 @@ async def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -111,59 +189,48 @@ async def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('TestJob', pipeline_response) + deserialized = self._deserialize("TestJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> _models.TestJob: """Retrieve the test job for the specified runbook. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: TestJob, or the result of cls(response) + :return: TestJob or the result of cls(response) :rtype: ~azure.mgmt.automation.models.TestJob - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.TestJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.TestJob] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -171,10 +238,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -182,59 +248,48 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('TestJob', pipeline_response) + deserialized = self._deserialize("TestJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob"} # type: ignore @distributed_trace_async async def resume( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: """Resume the test job. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_resume_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.resume.metadata['url'], + template_url=self.resume.metadata["url"], headers=_headers, params=_params, ) @@ -242,10 +297,9 @@ async def resume( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -256,52 +310,41 @@ async def resume( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - resume.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/resume"} # type: ignore - + resume.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/resume"} # type: ignore @distributed_trace_async async def stop( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: """Stop the test job. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_stop_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.stop.metadata['url'], + template_url=self.stop.metadata["url"], headers=_headers, params=_params, ) @@ -309,10 +352,9 @@ async def stop( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -323,52 +365,41 @@ async def stop( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - stop.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/stop"} # type: ignore - + stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/stop"} # type: ignore @distributed_trace_async async def suspend( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: """Suspend the test job. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_suspend_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.suspend.metadata['url'], + template_url=self.suspend.metadata["url"], headers=_headers, params=_params, ) @@ -376,10 +407,9 @@ async def suspend( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -390,5 +420,4 @@ async def suspend( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - suspend.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/suspend"} # type: ignore - + suspend.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/suspend"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_test_job_streams_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_test_job_streams_operations.py index d962901a2912..cc0b9a332f1a 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_test_job_streams_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_test_job_streams_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -22,9 +28,11 @@ from ..._vendor import _convert_request from ...operations._test_job_streams_operations import build_get_request, build_list_by_test_job_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class TestJobStreamsOperations: """ .. warning:: @@ -44,7 +52,6 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async async def get( self, @@ -56,42 +63,36 @@ async def get( ) -> _models.JobStream: """Retrieve a test job stream of the test job identified by runbook name and stream id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :param job_stream_id: The job stream id. + :param job_stream_id: The job stream id. Required. :type job_stream_id: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobStream, or the result of cls(response) + :return: JobStream or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobStream - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStream] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStream] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, job_stream_id=job_stream_id, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -99,10 +100,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -110,15 +110,14 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobStream', pipeline_response) + deserialized = self._deserialize("JobStream", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams/{jobStreamId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams/{jobStreamId}"} # type: ignore @distributed_trace def list_by_test_job( @@ -128,47 +127,42 @@ def list_by_test_job( runbook_name: str, filter: Optional[str] = None, **kwargs: Any - ) -> AsyncIterable[_models.JobStreamListResult]: + ) -> AsyncIterable["_models.JobStream"]: """Retrieve a list of test job streams identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either JobStreamListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.JobStreamListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either JobStream or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.JobStream] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStreamListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStreamListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_test_job_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, - api_version=api_version, + subscription_id=self._config.subscription_id, filter=filter, - template_url=self.list_by_test_job.metadata['url'], + api_version=api_version, + template_url=self.list_by_test_job.metadata["url"], headers=_headers, params=_params, ) @@ -176,18 +170,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_test_job_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - runbook_name=runbook_name, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -203,10 +186,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -217,8 +198,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_test_job.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams"} # type: ignore + list_by_test_job.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_usages_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_usages_operations.py index 01797311296a..af5c44a65aac 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_usages_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_usages_operations.py @@ -9,7 +9,13 @@ from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -21,9 +27,11 @@ from ..._vendor import _convert_request from ...operations._usages_operations import build_list_by_automation_account_request from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class UsagesOperations: """ .. warning:: @@ -43,47 +51,39 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.UsageListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Usage"]: """Retrieve the usage for the account id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either UsageListResult or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.UsageListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Usage or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Usage] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.UsageListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.UsageListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -91,16 +91,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -116,10 +107,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -130,8 +119,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/usages"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/usages"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_variable_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_variable_operations.py index b1b7063e99b7..4e1b8ec283b6 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_variable_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_variable_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,19 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._variable_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._variable_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class VariableOperations: """ .. warning:: @@ -44,47 +58,113 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, variable_name: str, parameters: _models.VariableCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Variable: """Create a variable. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param variable_name: The variable name. + :param variable_name: The variable name. Required. :type variable_name: str :param parameters: The parameters supplied to the create or update variable operation. + Required. :type parameters: ~azure.mgmt.automation.models.VariableCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Variable, or the result of cls(response) + :return: Variable or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Variable - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + variable_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Variable: + """Create a variable. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param variable_name: The variable name. Required. + :type variable_name: str + :param parameters: The parameters supplied to the create or update variable operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Variable or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Variable + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + variable_name: str, + parameters: Union[_models.VariableCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Variable: + """Create a variable. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param variable_name: The variable name. Required. + :type variable_name: str + :param parameters: The parameters supplied to the create or update variable operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.VariableCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Variable or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Variable + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Variable] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Variable] - _json = self._serialize.body(parameters, 'VariableCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VariableCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -94,7 +174,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -102,10 +183,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -114,59 +194,123 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Variable', pipeline_response) + deserialized = self._deserialize("Variable", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Variable', pipeline_response) + deserialized = self._deserialize("Variable", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, variable_name: str, parameters: _models.VariableUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Variable: """Update a variable. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param variable_name: The variable name. + :param variable_name: The variable name. Required. :type variable_name: str - :param parameters: The parameters supplied to the update variable operation. + :param parameters: The parameters supplied to the update variable operation. Required. :type parameters: ~azure.mgmt.automation.models.VariableUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Variable, or the result of cls(response) + :return: Variable or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Variable - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + variable_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Variable: + """Update a variable. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param variable_name: The variable name. Required. + :type variable_name: str + :param parameters: The parameters supplied to the update variable operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Variable or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Variable + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + variable_name: str, + parameters: Union[_models.VariableUpdateParameters, IO], + **kwargs: Any + ) -> _models.Variable: + """Update a variable. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param variable_name: The variable name. Required. + :type variable_name: str + :param parameters: The parameters supplied to the update variable operation. Is either a model + type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.VariableUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Variable or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Variable + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Variable] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Variable] - _json = self._serialize.body(parameters, 'VariableUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VariableUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -176,7 +320,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -184,10 +329,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -195,59 +339,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Variable', pipeline_response) + deserialized = self._deserialize("Variable", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - variable_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, variable_name: str, **kwargs: Any ) -> None: """Delete the variable. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param variable_name: The name of variable. + :param variable_name: The name of variable. Required. :type variable_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, variable_name=variable_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -255,10 +388,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -269,52 +401,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - variable_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, variable_name: str, **kwargs: Any ) -> _models.Variable: """Retrieve the variable identified by variable name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param variable_name: The name of variable. + :param variable_name: The name of variable. Required. :type variable_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Variable, or the result of cls(response) + :return: Variable or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Variable - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Variable] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Variable] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, variable_name=variable_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -322,10 +443,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -333,57 +453,48 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Variable', pipeline_response) + deserialized = self._deserialize("Variable", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> AsyncIterable[_models.VariableListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> AsyncIterable["_models.Variable"]: """Retrieve a list of variables. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VariableListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.VariableListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Variable or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Variable] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VariableListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VariableListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -391,16 +502,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -416,10 +518,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -430,8 +530,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_watcher_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_watcher_operations.py index bacebd618fe5..e72291763485 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_watcher_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_watcher_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,21 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._watcher_operations import build_create_or_update_request, build_delete_request, build_get_request, build_list_by_automation_account_request, build_start_request, build_stop_request, build_update_request +from ...operations._watcher_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_automation_account_request, + build_start_request, + build_stop_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class WatcherOperations: """ .. warning:: @@ -44,47 +60,111 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, watcher_name: str, parameters: _models.Watcher, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Watcher: """Create the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :param parameters: The create or update parameters for watcher. + :param parameters: The create or update parameters for watcher. Required. :type parameters: ~azure.mgmt.automation.models.Watcher - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Watcher, or the result of cls(response) + :return: Watcher or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Watcher - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + watcher_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Watcher: + """Create the watcher identified by watcher name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param watcher_name: The watcher name. Required. + :type watcher_name: str + :param parameters: The create or update parameters for watcher. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + watcher_name: str, + parameters: Union[_models.Watcher, IO], + **kwargs: Any + ) -> _models.Watcher: + """Create the watcher identified by watcher name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param watcher_name: The watcher name. Required. + :type watcher_name: str + :param parameters: The create or update parameters for watcher. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.Watcher or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Watcher] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Watcher] - _json = self._serialize.body(parameters, 'Watcher') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "Watcher") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -94,7 +174,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -102,10 +183,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -114,62 +194,51 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Watcher', pipeline_response) + deserialized = self._deserialize("Watcher", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Watcher', pipeline_response) + deserialized = self._deserialize("Watcher", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, watcher_name: str, **kwargs: Any ) -> _models.Watcher: """Retrieve the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Watcher, or the result of cls(response) + :return: Watcher or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Watcher - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Watcher] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Watcher] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, watcher_name=watcher_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -177,10 +246,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -188,56 +256,120 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Watcher', pipeline_response) + deserialized = self._deserialize("Watcher", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, watcher_name: str, parameters: _models.WatcherUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Watcher: """Update the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :param parameters: The update parameters for watcher. + :param parameters: The update parameters for watcher. Required. :type parameters: ~azure.mgmt.automation.models.WatcherUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Watcher, or the result of cls(response) + :return: Watcher or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Watcher - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + watcher_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Watcher: + """Update the watcher identified by watcher name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param watcher_name: The watcher name. Required. + :type watcher_name: str + :param parameters: The update parameters for watcher. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + watcher_name: str, + parameters: Union[_models.WatcherUpdateParameters, IO], + **kwargs: Any + ) -> _models.Watcher: + """Update the watcher identified by watcher name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param watcher_name: The watcher name. Required. + :type watcher_name: str + :param parameters: The update parameters for watcher. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.automation.models.WatcherUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Watcher] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Watcher] - _json = self._serialize.body(parameters, 'WatcherUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "WatcherUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -247,7 +379,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -255,10 +388,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -266,59 +398,48 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Watcher', pipeline_response) + deserialized = self._deserialize("Watcher", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, watcher_name: str, **kwargs: Any ) -> None: """Delete the watcher by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, watcher_name=watcher_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -326,10 +447,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -340,52 +460,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore @distributed_trace_async async def start( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, watcher_name: str, **kwargs: Any ) -> None: """Resume the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_start_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, watcher_name=watcher_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.start.metadata['url'], + template_url=self.start.metadata["url"], headers=_headers, params=_params, ) @@ -393,10 +502,9 @@ async def start( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -407,52 +515,41 @@ async def start( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - start.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/start"} # type: ignore - + start.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/start"} # type: ignore @distributed_trace_async async def stop( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, watcher_name: str, **kwargs: Any ) -> None: """Resume the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_stop_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, watcher_name=watcher_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.stop.metadata['url'], + template_url=self.stop.metadata["url"], headers=_headers, params=_params, ) @@ -460,10 +557,9 @@ async def stop( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -474,54 +570,44 @@ async def stop( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - stop.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/stop"} # type: ignore - + stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/stop"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> AsyncIterable[_models.WatcherListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.Watcher"]: """Retrieve a list of watchers. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either WatcherListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.WatcherListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Watcher or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.WatcherListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.WatcherListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -529,17 +615,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -555,10 +631,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -569,8 +643,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_webhook_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_webhook_operations.py index 74304573e683..bbcac3639ac2 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_webhook_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/aio/operations/_webhook_operations.py @@ -6,10 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest @@ -20,11 +26,20 @@ from ... import models as _models from ..._vendor import _convert_request -from ...operations._webhook_operations import build_create_or_update_request, build_delete_request, build_generate_uri_request, build_get_request, build_list_by_automation_account_request, build_update_request +from ...operations._webhook_operations import ( + build_create_or_update_request, + build_delete_request, + build_generate_uri_request, + build_get_request, + build_list_by_automation_account_request, + build_update_request, +) from .._vendor import MixinABC -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + class WebhookOperations: """ .. warning:: @@ -44,46 +59,34 @@ def __init__(self, *args, **kwargs) -> None: self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace_async - async def generate_uri( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> str: + async def generate_uri(self, resource_group_name: str, automation_account_name: str, **kwargs: Any) -> str: """Generates a Uri for use in creating a webhook. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: str, or the result of cls(response) + :return: str or the result of cls(response) :rtype: str - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[str] - request = build_generate_uri_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.generate_uri.metadata['url'], + template_url=self.generate_uri.metadata["url"], headers=_headers, params=_params, ) @@ -91,10 +94,9 @@ async def generate_uri( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -102,59 +104,48 @@ async def generate_uri( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('str', pipeline_response) + deserialized = self._deserialize("str", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - generate_uri.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/generateUri"} # type: ignore - + generate_uri.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/generateUri"} # type: ignore @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - webhook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, webhook_name: str, **kwargs: Any ) -> None: """Delete the webhook by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param webhook_name: The webhook name. + :param webhook_name: The webhook name. Required. :type webhook_name: str - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, webhook_name=webhook_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -162,10 +153,9 @@ async def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -176,52 +166,41 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore @distributed_trace_async async def get( - self, - resource_group_name: str, - automation_account_name: str, - webhook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, webhook_name: str, **kwargs: Any ) -> _models.Webhook: """Retrieve the webhook identified by webhook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param webhook_name: The webhook name. + :param webhook_name: The webhook name. Required. :type webhook_name: str - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Webhook, or the result of cls(response) + :return: Webhook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Webhook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Webhook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Webhook] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, webhook_name=webhook_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -229,10 +208,9 @@ async def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -240,56 +218,120 @@ async def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Webhook', pipeline_response) + deserialized = self._deserialize("Webhook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - - @distributed_trace_async + @overload async def create_or_update( self, resource_group_name: str, automation_account_name: str, webhook_name: str, parameters: _models.WebhookCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Webhook: """Create the webhook identified by webhook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param webhook_name: The webhook name. + :param webhook_name: The webhook name. Required. :type webhook_name: str - :param parameters: The create or update parameters for webhook. + :param parameters: The create or update parameters for webhook. Required. :type parameters: ~azure.mgmt.automation.models.WebhookCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Webhook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Webhook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + webhook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Webhook: + """Create the webhook identified by webhook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param webhook_name: The webhook name. Required. + :type webhook_name: str + :param parameters: The create or update parameters for webhook. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Webhook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Webhook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + webhook_name: str, + parameters: Union[_models.WebhookCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Webhook: + """Create the webhook identified by webhook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param webhook_name: The webhook name. Required. + :type webhook_name: str + :param parameters: The create or update parameters for webhook. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.WebhookCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Webhook, or the result of cls(response) + :return: Webhook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Webhook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Webhook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Webhook] - _json = self._serialize.body(parameters, 'WebhookCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "WebhookCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -299,7 +341,8 @@ async def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -307,10 +350,9 @@ async def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -319,59 +361,123 @@ async def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Webhook', pipeline_response) + deserialized = self._deserialize("Webhook", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Webhook', pipeline_response) + deserialized = self._deserialize("Webhook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - @distributed_trace_async + @overload async def update( self, resource_group_name: str, automation_account_name: str, webhook_name: str, parameters: _models.WebhookUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Webhook: """Update the webhook identified by webhook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param webhook_name: The webhook name. + :param webhook_name: The webhook name. Required. :type webhook_name: str - :param parameters: The update parameters for webhook. + :param parameters: The update parameters for webhook. Required. :type parameters: ~azure.mgmt.automation.models.WebhookUpdateParameters - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Webhook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Webhook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update( + self, + resource_group_name: str, + automation_account_name: str, + webhook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Webhook: + """Update the webhook identified by webhook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param webhook_name: The webhook name. Required. + :type webhook_name: str + :param parameters: The update parameters for webhook. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Webhook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Webhook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update( + self, + resource_group_name: str, + automation_account_name: str, + webhook_name: str, + parameters: Union[_models.WebhookUpdateParameters, IO], + **kwargs: Any + ) -> _models.Webhook: + """Update the webhook identified by webhook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param webhook_name: The webhook name. Required. + :type webhook_name: str + :param parameters: The update parameters for webhook. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.automation.models.WebhookUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Webhook, or the result of cls(response) + :return: Webhook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Webhook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Webhook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Webhook] - _json = self._serialize.body(parameters, 'WebhookUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "WebhookUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -381,7 +487,8 @@ async def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -389,10 +496,9 @@ async def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -400,61 +506,51 @@ async def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Webhook', pipeline_response) + deserialized = self._deserialize("Webhook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> AsyncIterable[_models.WebhookListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> AsyncIterable["_models.Webhook"]: """Retrieve a list of webhooks. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either WebhookListResult or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.WebhookListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Webhook or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.Webhook] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.WebhookListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.WebhookListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -462,17 +558,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -488,10 +574,8 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -502,8 +586,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/__init__.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/__init__.py index 72ac4f398457..3211780c80d6 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/__init__.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/__init__.py @@ -26,7 +26,6 @@ from ._models_py3 import CertificateCreateOrUpdateParameters from ._models_py3 import CertificateListResult from ._models_py3 import CertificateUpdateParameters -from ._models_py3 import ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties from ._models_py3 import Connection from ._models_py3 import ConnectionCreateOrUpdateParameters from ._models_py3 import ConnectionListResult @@ -42,6 +41,9 @@ from ._models_py3 import CredentialCreateOrUpdateParameters from ._models_py3 import CredentialListResult from ._models_py3 import CredentialUpdateParameters +from ._models_py3 import DeletedAutomationAccount +from ._models_py3 import DeletedAutomationAccountListResult +from ._models_py3 import Dimension from ._models_py3 import DscCompilationJob from ._models_py3 import DscCompilationJobCreateParameters from ._models_py3 import DscCompilationJobListResult @@ -74,9 +76,7 @@ from ._models_py3 import HybridRunbookWorkerCreateParameters from ._models_py3 import HybridRunbookWorkerGroup from ._models_py3 import HybridRunbookWorkerGroupCreateOrUpdateParameters -from ._models_py3 import HybridRunbookWorkerGroupUpdateParameters from ._models_py3 import HybridRunbookWorkerGroupsListResult -from ._models_py3 import HybridRunbookWorkerLegacy from ._models_py3 import HybridRunbookWorkerMoveParameters from ._models_py3 import HybridRunbookWorkersListResult from ._models_py3 import Identity @@ -95,6 +95,8 @@ from ._models_py3 import KeyVaultProperties from ._models_py3 import LinkedWorkspace from ._models_py3 import LinuxProperties +from ._models_py3 import LogSpecification +from ._models_py3 import MetricSpecification from ._models_py3 import Module from ._models_py3 import ModuleCreateOrUpdateParameters from ._models_py3 import ModuleErrorInfo @@ -107,6 +109,7 @@ from ._models_py3 import Operation from ._models_py3 import OperationDisplay from ._models_py3 import OperationListResult +from ._models_py3 import OperationPropertiesFormatServiceSpecification from ._models_py3 import PrivateEndpointConnection from ._models_py3 import PrivateEndpointConnectionListResult from ._models_py3 import PrivateEndpointProperty @@ -174,6 +177,7 @@ from ._models_py3 import Usage from ._models_py3 import UsageCounterName from ._models_py3 import UsageListResult +from ._models_py3 import UserAssignedIdentitiesProperties from ._models_py3 import Variable from ._models_py3 import VariableCreateOrUpdateParameters from ._models_py3 import VariableListResult @@ -187,257 +191,259 @@ from ._models_py3 import WebhookUpdateParameters from ._models_py3 import WindowsProperties - -from ._automation_client_enums import ( - AgentRegistrationKeyName, - AutomationAccountState, - AutomationKeyName, - AutomationKeyPermissions, - ContentSourceType, - CountType, - CreatedByType, - DscConfigurationState, - EncryptionKeySourceType, - GraphRunbookType, - GroupTypeEnum, - HttpStatusCode, - JobProvisioningState, - JobStatus, - JobStreamType, - LinuxUpdateClasses, - ModuleProvisioningState, - OperatingSystemType, - ProvisioningState, - ResourceIdentityType, - RunbookState, - RunbookTypeEnum, - ScheduleDay, - ScheduleFrequency, - SkuNameEnum, - SourceType, - StreamType, - SyncType, - TagOperators, - TokenType, - WindowsUpdateClasses, - WorkerType, -) +from ._automation_client_enums import AgentRegistrationKeyName +from ._automation_client_enums import AutomationAccountState +from ._automation_client_enums import AutomationKeyName +from ._automation_client_enums import AutomationKeyPermissions +from ._automation_client_enums import ContentSourceType +from ._automation_client_enums import CountType +from ._automation_client_enums import CreatedByType +from ._automation_client_enums import DscConfigurationState +from ._automation_client_enums import EncryptionKeySourceType +from ._automation_client_enums import GraphRunbookType +from ._automation_client_enums import GroupTypeEnum +from ._automation_client_enums import HttpStatusCode +from ._automation_client_enums import JobProvisioningState +from ._automation_client_enums import JobStatus +from ._automation_client_enums import JobStreamType +from ._automation_client_enums import LinuxUpdateClasses +from ._automation_client_enums import ModuleProvisioningState +from ._automation_client_enums import OperatingSystemType +from ._automation_client_enums import ProvisioningState +from ._automation_client_enums import ResourceIdentityType +from ._automation_client_enums import RunbookState +from ._automation_client_enums import RunbookTypeEnum +from ._automation_client_enums import ScheduleDay +from ._automation_client_enums import ScheduleFrequency +from ._automation_client_enums import SkuNameEnum +from ._automation_client_enums import SourceType +from ._automation_client_enums import StreamType +from ._automation_client_enums import SyncType +from ._automation_client_enums import TagOperators +from ._automation_client_enums import TokenType +from ._automation_client_enums import WindowsUpdateClasses +from ._automation_client_enums import WorkerType from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'Activity', - 'ActivityListResult', - 'ActivityOutputType', - 'ActivityParameter', - 'ActivityParameterSet', - 'ActivityParameterValidationSet', - 'AdvancedSchedule', - 'AdvancedScheduleMonthlyOccurrence', - 'AgentRegistration', - 'AgentRegistrationKeys', - 'AgentRegistrationRegenerateKeyParameter', - 'AutomationAccount', - 'AutomationAccountCreateOrUpdateParameters', - 'AutomationAccountListResult', - 'AutomationAccountUpdateParameters', - 'AzureQueryProperties', - 'Certificate', - 'CertificateCreateOrUpdateParameters', - 'CertificateListResult', - 'CertificateUpdateParameters', - 'ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties', - 'Connection', - 'ConnectionCreateOrUpdateParameters', - 'ConnectionListResult', - 'ConnectionType', - 'ConnectionTypeAssociationProperty', - 'ConnectionTypeCreateOrUpdateParameters', - 'ConnectionTypeListResult', - 'ConnectionUpdateParameters', - 'ContentHash', - 'ContentLink', - 'ContentSource', - 'Credential', - 'CredentialCreateOrUpdateParameters', - 'CredentialListResult', - 'CredentialUpdateParameters', - 'DscCompilationJob', - 'DscCompilationJobCreateParameters', - 'DscCompilationJobListResult', - 'DscConfiguration', - 'DscConfigurationAssociationProperty', - 'DscConfigurationCreateOrUpdateParameters', - 'DscConfigurationListResult', - 'DscConfigurationParameter', - 'DscConfigurationUpdateParameters', - 'DscMetaConfiguration', - 'DscNode', - 'DscNodeConfiguration', - 'DscNodeConfigurationCreateOrUpdateParameters', - 'DscNodeConfigurationListResult', - 'DscNodeExtensionHandlerAssociationProperty', - 'DscNodeListResult', - 'DscNodeReport', - 'DscNodeReportListResult', - 'DscNodeUpdateParameters', - 'DscNodeUpdateParametersProperties', - 'DscReportError', - 'DscReportResource', - 'DscReportResourceNavigation', - 'EncryptionProperties', - 'EncryptionPropertiesIdentity', - 'ErrorResponse', - 'FieldDefinition', - 'GraphicalRunbookContent', - 'HybridRunbookWorker', - 'HybridRunbookWorkerCreateParameters', - 'HybridRunbookWorkerGroup', - 'HybridRunbookWorkerGroupCreateOrUpdateParameters', - 'HybridRunbookWorkerGroupUpdateParameters', - 'HybridRunbookWorkerGroupsListResult', - 'HybridRunbookWorkerLegacy', - 'HybridRunbookWorkerMoveParameters', - 'HybridRunbookWorkersListResult', - 'Identity', - 'Job', - 'JobCollectionItem', - 'JobCreateParameters', - 'JobListResultV2', - 'JobNavigation', - 'JobSchedule', - 'JobScheduleCreateParameters', - 'JobScheduleListResult', - 'JobStream', - 'JobStreamListResult', - 'Key', - 'KeyListResult', - 'KeyVaultProperties', - 'LinkedWorkspace', - 'LinuxProperties', - 'Module', - 'ModuleCreateOrUpdateParameters', - 'ModuleErrorInfo', - 'ModuleListResult', - 'ModuleUpdateParameters', - 'NodeCount', - 'NodeCountProperties', - 'NodeCounts', - 'NonAzureQueryProperties', - 'Operation', - 'OperationDisplay', - 'OperationListResult', - 'PrivateEndpointConnection', - 'PrivateEndpointConnectionListResult', - 'PrivateEndpointProperty', - 'PrivateLinkResource', - 'PrivateLinkResourceListResult', - 'PrivateLinkServiceConnectionStateProperty', - 'ProxyResource', - 'PythonPackageCreateParameters', - 'PythonPackageUpdateParameters', - 'RawGraphicalRunbookContent', - 'Resource', - 'RunAsCredentialAssociationProperty', - 'Runbook', - 'RunbookAssociationProperty', - 'RunbookCreateOrUpdateDraftParameters', - 'RunbookCreateOrUpdateDraftProperties', - 'RunbookCreateOrUpdateParameters', - 'RunbookDraft', - 'RunbookDraftUndoEditResult', - 'RunbookListResult', - 'RunbookParameter', - 'RunbookUpdateParameters', - 'SUCScheduleProperties', - 'Schedule', - 'ScheduleAssociationProperty', - 'ScheduleCreateOrUpdateParameters', - 'ScheduleListResult', - 'ScheduleUpdateParameters', - 'Sku', - 'SoftwareUpdateConfiguration', - 'SoftwareUpdateConfigurationCollectionItem', - 'SoftwareUpdateConfigurationListResult', - 'SoftwareUpdateConfigurationMachineRun', - 'SoftwareUpdateConfigurationMachineRunListResult', - 'SoftwareUpdateConfigurationRun', - 'SoftwareUpdateConfigurationRunListResult', - 'SoftwareUpdateConfigurationRunTaskProperties', - 'SoftwareUpdateConfigurationRunTasks', - 'SoftwareUpdateConfigurationTasks', - 'SourceControl', - 'SourceControlCreateOrUpdateParameters', - 'SourceControlListResult', - 'SourceControlSecurityTokenProperties', - 'SourceControlSyncJob', - 'SourceControlSyncJobById', - 'SourceControlSyncJobCreateParameters', - 'SourceControlSyncJobListResult', - 'SourceControlSyncJobStream', - 'SourceControlSyncJobStreamById', - 'SourceControlSyncJobStreamsListBySyncJob', - 'SourceControlUpdateParameters', - 'Statistics', - 'StatisticsListResult', - 'SystemData', - 'TagSettingsProperties', - 'TargetProperties', - 'TaskProperties', - 'TestJob', - 'TestJobCreateParameters', - 'TrackedResource', - 'TypeField', - 'TypeFieldListResult', - 'UpdateConfiguration', - 'UpdateConfigurationNavigation', - 'Usage', - 'UsageCounterName', - 'UsageListResult', - 'Variable', - 'VariableCreateOrUpdateParameters', - 'VariableListResult', - 'VariableUpdateParameters', - 'Watcher', - 'WatcherListResult', - 'WatcherUpdateParameters', - 'Webhook', - 'WebhookCreateOrUpdateParameters', - 'WebhookListResult', - 'WebhookUpdateParameters', - 'WindowsProperties', - 'AgentRegistrationKeyName', - 'AutomationAccountState', - 'AutomationKeyName', - 'AutomationKeyPermissions', - 'ContentSourceType', - 'CountType', - 'CreatedByType', - 'DscConfigurationState', - 'EncryptionKeySourceType', - 'GraphRunbookType', - 'GroupTypeEnum', - 'HttpStatusCode', - 'JobProvisioningState', - 'JobStatus', - 'JobStreamType', - 'LinuxUpdateClasses', - 'ModuleProvisioningState', - 'OperatingSystemType', - 'ProvisioningState', - 'ResourceIdentityType', - 'RunbookState', - 'RunbookTypeEnum', - 'ScheduleDay', - 'ScheduleFrequency', - 'SkuNameEnum', - 'SourceType', - 'StreamType', - 'SyncType', - 'TagOperators', - 'TokenType', - 'WindowsUpdateClasses', - 'WorkerType', + "Activity", + "ActivityListResult", + "ActivityOutputType", + "ActivityParameter", + "ActivityParameterSet", + "ActivityParameterValidationSet", + "AdvancedSchedule", + "AdvancedScheduleMonthlyOccurrence", + "AgentRegistration", + "AgentRegistrationKeys", + "AgentRegistrationRegenerateKeyParameter", + "AutomationAccount", + "AutomationAccountCreateOrUpdateParameters", + "AutomationAccountListResult", + "AutomationAccountUpdateParameters", + "AzureQueryProperties", + "Certificate", + "CertificateCreateOrUpdateParameters", + "CertificateListResult", + "CertificateUpdateParameters", + "Connection", + "ConnectionCreateOrUpdateParameters", + "ConnectionListResult", + "ConnectionType", + "ConnectionTypeAssociationProperty", + "ConnectionTypeCreateOrUpdateParameters", + "ConnectionTypeListResult", + "ConnectionUpdateParameters", + "ContentHash", + "ContentLink", + "ContentSource", + "Credential", + "CredentialCreateOrUpdateParameters", + "CredentialListResult", + "CredentialUpdateParameters", + "DeletedAutomationAccount", + "DeletedAutomationAccountListResult", + "Dimension", + "DscCompilationJob", + "DscCompilationJobCreateParameters", + "DscCompilationJobListResult", + "DscConfiguration", + "DscConfigurationAssociationProperty", + "DscConfigurationCreateOrUpdateParameters", + "DscConfigurationListResult", + "DscConfigurationParameter", + "DscConfigurationUpdateParameters", + "DscMetaConfiguration", + "DscNode", + "DscNodeConfiguration", + "DscNodeConfigurationCreateOrUpdateParameters", + "DscNodeConfigurationListResult", + "DscNodeExtensionHandlerAssociationProperty", + "DscNodeListResult", + "DscNodeReport", + "DscNodeReportListResult", + "DscNodeUpdateParameters", + "DscNodeUpdateParametersProperties", + "DscReportError", + "DscReportResource", + "DscReportResourceNavigation", + "EncryptionProperties", + "EncryptionPropertiesIdentity", + "ErrorResponse", + "FieldDefinition", + "GraphicalRunbookContent", + "HybridRunbookWorker", + "HybridRunbookWorkerCreateParameters", + "HybridRunbookWorkerGroup", + "HybridRunbookWorkerGroupCreateOrUpdateParameters", + "HybridRunbookWorkerGroupsListResult", + "HybridRunbookWorkerMoveParameters", + "HybridRunbookWorkersListResult", + "Identity", + "Job", + "JobCollectionItem", + "JobCreateParameters", + "JobListResultV2", + "JobNavigation", + "JobSchedule", + "JobScheduleCreateParameters", + "JobScheduleListResult", + "JobStream", + "JobStreamListResult", + "Key", + "KeyListResult", + "KeyVaultProperties", + "LinkedWorkspace", + "LinuxProperties", + "LogSpecification", + "MetricSpecification", + "Module", + "ModuleCreateOrUpdateParameters", + "ModuleErrorInfo", + "ModuleListResult", + "ModuleUpdateParameters", + "NodeCount", + "NodeCountProperties", + "NodeCounts", + "NonAzureQueryProperties", + "Operation", + "OperationDisplay", + "OperationListResult", + "OperationPropertiesFormatServiceSpecification", + "PrivateEndpointConnection", + "PrivateEndpointConnectionListResult", + "PrivateEndpointProperty", + "PrivateLinkResource", + "PrivateLinkResourceListResult", + "PrivateLinkServiceConnectionStateProperty", + "ProxyResource", + "PythonPackageCreateParameters", + "PythonPackageUpdateParameters", + "RawGraphicalRunbookContent", + "Resource", + "RunAsCredentialAssociationProperty", + "Runbook", + "RunbookAssociationProperty", + "RunbookCreateOrUpdateDraftParameters", + "RunbookCreateOrUpdateDraftProperties", + "RunbookCreateOrUpdateParameters", + "RunbookDraft", + "RunbookDraftUndoEditResult", + "RunbookListResult", + "RunbookParameter", + "RunbookUpdateParameters", + "SUCScheduleProperties", + "Schedule", + "ScheduleAssociationProperty", + "ScheduleCreateOrUpdateParameters", + "ScheduleListResult", + "ScheduleUpdateParameters", + "Sku", + "SoftwareUpdateConfiguration", + "SoftwareUpdateConfigurationCollectionItem", + "SoftwareUpdateConfigurationListResult", + "SoftwareUpdateConfigurationMachineRun", + "SoftwareUpdateConfigurationMachineRunListResult", + "SoftwareUpdateConfigurationRun", + "SoftwareUpdateConfigurationRunListResult", + "SoftwareUpdateConfigurationRunTaskProperties", + "SoftwareUpdateConfigurationRunTasks", + "SoftwareUpdateConfigurationTasks", + "SourceControl", + "SourceControlCreateOrUpdateParameters", + "SourceControlListResult", + "SourceControlSecurityTokenProperties", + "SourceControlSyncJob", + "SourceControlSyncJobById", + "SourceControlSyncJobCreateParameters", + "SourceControlSyncJobListResult", + "SourceControlSyncJobStream", + "SourceControlSyncJobStreamById", + "SourceControlSyncJobStreamsListBySyncJob", + "SourceControlUpdateParameters", + "Statistics", + "StatisticsListResult", + "SystemData", + "TagSettingsProperties", + "TargetProperties", + "TaskProperties", + "TestJob", + "TestJobCreateParameters", + "TrackedResource", + "TypeField", + "TypeFieldListResult", + "UpdateConfiguration", + "UpdateConfigurationNavigation", + "Usage", + "UsageCounterName", + "UsageListResult", + "UserAssignedIdentitiesProperties", + "Variable", + "VariableCreateOrUpdateParameters", + "VariableListResult", + "VariableUpdateParameters", + "Watcher", + "WatcherListResult", + "WatcherUpdateParameters", + "Webhook", + "WebhookCreateOrUpdateParameters", + "WebhookListResult", + "WebhookUpdateParameters", + "WindowsProperties", + "AgentRegistrationKeyName", + "AutomationAccountState", + "AutomationKeyName", + "AutomationKeyPermissions", + "ContentSourceType", + "CountType", + "CreatedByType", + "DscConfigurationState", + "EncryptionKeySourceType", + "GraphRunbookType", + "GroupTypeEnum", + "HttpStatusCode", + "JobProvisioningState", + "JobStatus", + "JobStreamType", + "LinuxUpdateClasses", + "ModuleProvisioningState", + "OperatingSystemType", + "ProvisioningState", + "ResourceIdentityType", + "RunbookState", + "RunbookTypeEnum", + "ScheduleDay", + "ScheduleFrequency", + "SkuNameEnum", + "SourceType", + "StreamType", + "SyncType", + "TagOperators", + "TokenType", + "WindowsUpdateClasses", + "WorkerType", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_patch_sdk() diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_automation_client_enums.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_automation_client_enums.py index f3ec377e839d..f1305838c80d 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_automation_client_enums.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_automation_client_enums.py @@ -11,87 +11,90 @@ class AgentRegistrationKeyName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the agent registration key name - primary or secondary. - """ + """Gets or sets the agent registration key name - primary or secondary.""" PRIMARY = "primary" SECONDARY = "secondary" + class AutomationAccountState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets status of account. - """ + """Gets status of account.""" OK = "Ok" UNAVAILABLE = "Unavailable" SUSPENDED = "Suspended" + class AutomationKeyName(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Automation key name. - """ + """Automation key name.""" PRIMARY = "Primary" SECONDARY = "Secondary" + class AutomationKeyPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Automation key permissions. - """ + """Automation key permissions.""" READ = "Read" FULL = "Full" + class ContentSourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the content source type. - """ + """Gets or sets the content source type.""" EMBEDDED_CONTENT = "embeddedContent" URI = "uri" + class CountType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """CountType.""" STATUS = "status" NODECONFIGURATION = "nodeconfiguration" + class CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of identity that created the resource. - """ + """The type of identity that created the resource.""" USER = "User" APPLICATION = "Application" MANAGED_IDENTITY = "ManagedIdentity" KEY = "Key" + class DscConfigurationState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the state of the configuration. - """ + """Gets or sets the state of the configuration.""" NEW = "New" EDIT = "Edit" PUBLISHED = "Published" + class EncryptionKeySourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Encryption Key Source - """ + """Encryption Key Source.""" MICROSOFT_AUTOMATION = "Microsoft.Automation" MICROSOFT_KEYVAULT = "Microsoft.Keyvault" + class GraphRunbookType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Runbook Type - """ + """Runbook Type.""" GRAPH_POWER_SHELL = "GraphPowerShell" GRAPH_POWER_SHELL_WORKFLOW = "GraphPowerShellWorkflow" + class GroupTypeEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Type of the HybridWorkerGroup. - """ + """Type of the HybridWorkerGroup.""" USER = "User" SYSTEM = "System" + class HttpStatusCode(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """HttpStatusCode.""" - CONTINUE_ENUM = "Continue" + CONTINUE = "Continue" SWITCHING_PROTOCOLS = "SwitchingProtocols" OK = "OK" CREATED = "Created" @@ -139,18 +142,18 @@ class HttpStatusCode(str, Enum, metaclass=CaseInsensitiveEnumMeta): GATEWAY_TIMEOUT = "GatewayTimeout" HTTP_VERSION_NOT_SUPPORTED = "HttpVersionNotSupported" + class JobProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The provisioning state of the resource. - """ + """The provisioning state of the resource.""" FAILED = "Failed" SUCCEEDED = "Succeeded" SUSPENDED = "Suspended" PROCESSING = "Processing" + class JobStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the status of the job. - """ + """Gets or sets the status of the job.""" NEW = "New" ACTIVATING = "Activating" @@ -166,9 +169,9 @@ class JobStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): RESUMING = "Resuming" REMOVING = "Removing" + class JobStreamType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the stream type. - """ + """Gets or sets the stream type.""" PROGRESS = "Progress" OUTPUT = "Output" @@ -178,18 +181,18 @@ class JobStreamType(str, Enum, metaclass=CaseInsensitiveEnumMeta): VERBOSE = "Verbose" ANY = "Any" + class LinuxUpdateClasses(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Update classifications included in the software update configuration. - """ + """Update classifications included in the software update configuration.""" UNCLASSIFIED = "Unclassified" CRITICAL = "Critical" SECURITY = "Security" OTHER = "Other" + class ModuleProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the provisioning state of the module. - """ + """Gets or sets the provisioning state of the module.""" CREATED = "Created" CREATING = "Creating" @@ -208,41 +211,41 @@ class ModuleProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): CANCELLED = "Cancelled" UPDATING = "Updating" + class OperatingSystemType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Target operating system for the software update configuration. - """ + """Target operating system for the software update configuration.""" WINDOWS = "Windows" LINUX = "Linux" + class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The provisioning state of the job. - """ + """The provisioning state of the job.""" COMPLETED = "Completed" FAILED = "Failed" RUNNING = "Running" + class ResourceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The identity type. - """ + """The identity type.""" SYSTEM_ASSIGNED = "SystemAssigned" USER_ASSIGNED = "UserAssigned" SYSTEM_ASSIGNED_USER_ASSIGNED = "SystemAssigned, UserAssigned" NONE = "None" + class RunbookState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the state of the runbook. - """ + """Gets or sets the state of the runbook.""" NEW = "New" EDIT = "Edit" PUBLISHED = "Published" + class RunbookTypeEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the type of the runbook. - """ + """Gets or sets the type of the runbook.""" SCRIPT = "Script" GRAPH = "Graph" @@ -253,6 +256,7 @@ class RunbookTypeEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta): PYTHON2 = "Python2" PYTHON3 = "Python3" + class ScheduleDay(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Day of the occurrence. Must be one of monday, tuesday, wednesday, thursday, friday, saturday, sunday. @@ -266,9 +270,9 @@ class ScheduleDay(str, Enum, metaclass=CaseInsensitiveEnumMeta): SATURDAY = "Saturday" SUNDAY = "Sunday" + class ScheduleFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the frequency of the schedule. - """ + """Gets or sets the frequency of the schedule.""" ONE_TIME = "OneTime" DAY = "Day" @@ -278,52 +282,53 @@ class ScheduleFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta): #: The minimum allowed interval for Minute schedules is 15 minutes. MINUTE = "Minute" + class SkuNameEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Gets or sets the SKU name of the account. - """ + """Gets or sets the SKU name of the account.""" FREE = "Free" BASIC = "Basic" + class SourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The source type. Must be one of VsoGit, VsoTfvc, GitHub. - """ + """The source type. Must be one of VsoGit, VsoTfvc, GitHub.""" VSO_GIT = "VsoGit" VSO_TFVC = "VsoTfvc" GIT_HUB = "GitHub" + class StreamType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The type of the sync job stream. - """ + """The type of the sync job stream.""" ERROR = "Error" OUTPUT = "Output" + class SyncType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The sync type. - """ + """The sync type.""" PARTIAL_SYNC = "PartialSync" FULL_SYNC = "FullSync" + class TagOperators(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Filter VMs by Any or All specified tags. - """ + """Filter VMs by Any or All specified tags.""" ALL = "All" ANY = "Any" + class TokenType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The token type. Must be either PersonalAccessToken or Oauth. - """ + """The token type. Must be either PersonalAccessToken or Oauth.""" PERSONAL_ACCESS_TOKEN = "PersonalAccessToken" OAUTH = "Oauth" + class WindowsUpdateClasses(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Update classification included in the software update configuration. A comma separated string - with required values + with required values. """ UNCLASSIFIED = "Unclassified" @@ -336,9 +341,9 @@ class WindowsUpdateClasses(str, Enum, metaclass=CaseInsensitiveEnumMeta): TOOLS = "Tools" UPDATES = "Updates" + class WorkerType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Type of the HybridWorker. - """ + """Type of the HybridWorker.""" HYBRID_V1 = "HybridV1" HYBRID_V2 = "HybridV2" diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_models_py3.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_models_py3.py index 3469b23ced01..0a55f1a2b47c 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_models_py3.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_models_py3.py @@ -1,4 +1,5 @@ # coding=utf-8 +# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -7,17 +8,22 @@ # -------------------------------------------------------------------------- import datetime +import sys from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from .. import _serialization if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - import __init__ as _models + from .. import models as _models +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping +else: + from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports +JSON = MutableMapping[str, Any] # pylint: disable=unsubscriptable-object -class Activity(msrest.serialization.Model): +class Activity(_serialization.Model): """Definition of the activity. Variables are only populated by the server, and will be ignored when sending a request. @@ -41,24 +47,24 @@ class Activity(msrest.serialization.Model): """ _validation = { - 'name': {'readonly': True}, + "name": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'definition': {'key': 'properties.definition', 'type': 'str'}, - 'parameter_sets': {'key': 'properties.parameterSets', 'type': '[ActivityParameterSet]'}, - 'output_types': {'key': 'properties.outputTypes', 'type': '[ActivityOutputType]'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "definition": {"key": "properties.definition", "type": "str"}, + "parameter_sets": {"key": "properties.parameterSets", "type": "[ActivityParameterSet]"}, + "output_types": {"key": "properties.outputTypes", "type": "[ActivityOutputType]"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( self, *, - id: Optional[str] = None, + id: Optional[str] = None, # pylint: disable=redefined-builtin definition: Optional[str] = None, parameter_sets: Optional[List["_models.ActivityParameterSet"]] = None, output_types: Optional[List["_models.ActivityOutputType"]] = None, @@ -83,7 +89,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(Activity, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.name = None self.definition = definition @@ -94,7 +100,7 @@ def __init__( self.description = description -class ActivityListResult(msrest.serialization.Model): +class ActivityListResult(_serialization.Model): """The response model for the list activity operation. :ivar value: Gets or sets a list of activities. @@ -104,29 +110,23 @@ class ActivityListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Activity]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Activity]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.Activity"]] = None, - next_link: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Activity"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: Gets or sets a list of activities. :paramtype value: list[~azure.mgmt.automation.models.Activity] :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(ActivityListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ActivityOutputType(msrest.serialization.Model): +class ActivityOutputType(_serialization.Model): """Definition of the activity output type. :ivar name: Gets or sets the name of the activity output type. @@ -136,29 +136,23 @@ class ActivityOutputType(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - type: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, type: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the activity output type. :paramtype name: str :keyword type: Gets or sets the type of the activity output type. :paramtype type: str """ - super(ActivityOutputType, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.type = type -class ActivityParameter(msrest.serialization.Model): +class ActivityParameter(_serialization.Model): """Definition of the activity parameter. :ivar name: Gets or sets the name of the activity parameter. @@ -171,7 +165,7 @@ class ActivityParameter(msrest.serialization.Model): :ivar is_dynamic: Gets or sets a Boolean value that indicates true if the parameter is dynamic. :vartype is_dynamic: bool :ivar position: Gets or sets the position of the activity parameter. - :vartype position: long + :vartype position: int :ivar value_from_pipeline: Gets or sets a Boolean value that indicates true if the parameter can take values from the incoming pipeline objects. This setting is used if the cmdlet must access the complete input object. false indicates that the parameter cannot take values from @@ -194,16 +188,16 @@ class ActivityParameter(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'is_mandatory': {'key': 'isMandatory', 'type': 'bool'}, - 'is_dynamic': {'key': 'isDynamic', 'type': 'bool'}, - 'position': {'key': 'position', 'type': 'long'}, - 'value_from_pipeline': {'key': 'valueFromPipeline', 'type': 'bool'}, - 'value_from_pipeline_by_property_name': {'key': 'valueFromPipelineByPropertyName', 'type': 'bool'}, - 'value_from_remaining_arguments': {'key': 'valueFromRemainingArguments', 'type': 'bool'}, - 'description': {'key': 'description', 'type': 'str'}, - 'validation_set': {'key': 'validationSet', 'type': '[ActivityParameterValidationSet]'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "is_mandatory": {"key": "isMandatory", "type": "bool"}, + "is_dynamic": {"key": "isDynamic", "type": "bool"}, + "position": {"key": "position", "type": "int"}, + "value_from_pipeline": {"key": "valueFromPipeline", "type": "bool"}, + "value_from_pipeline_by_property_name": {"key": "valueFromPipelineByPropertyName", "type": "bool"}, + "value_from_remaining_arguments": {"key": "valueFromRemainingArguments", "type": "bool"}, + "description": {"key": "description", "type": "str"}, + "validation_set": {"key": "validationSet", "type": "[ActivityParameterValidationSet]"}, } def __init__( @@ -233,7 +227,7 @@ def __init__( dynamic. :paramtype is_dynamic: bool :keyword position: Gets or sets the position of the activity parameter. - :paramtype position: long + :paramtype position: int :keyword value_from_pipeline: Gets or sets a Boolean value that indicates true if the parameter can take values from the incoming pipeline objects. This setting is used if the cmdlet must access the complete input object. false indicates that the parameter cannot take values from @@ -254,7 +248,7 @@ def __init__( :keyword validation_set: Gets or sets the validation set of activity parameter. :paramtype validation_set: list[~azure.mgmt.automation.models.ActivityParameterValidationSet] """ - super(ActivityParameter, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.type = type self.is_mandatory = is_mandatory @@ -267,7 +261,7 @@ def __init__( self.validation_set = validation_set -class ActivityParameterSet(msrest.serialization.Model): +class ActivityParameterSet(_serialization.Model): """Definition of the activity parameter set. :ivar name: Gets or sets the name of the activity parameter set. @@ -277,16 +271,12 @@ class ActivityParameterSet(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'parameters': {'key': 'parameters', 'type': '[ActivityParameter]'}, + "name": {"key": "name", "type": "str"}, + "parameters": {"key": "parameters", "type": "[ActivityParameter]"}, } def __init__( - self, - *, - name: Optional[str] = None, - parameters: Optional[List["_models.ActivityParameter"]] = None, - **kwargs + self, *, name: Optional[str] = None, parameters: Optional[List["_models.ActivityParameter"]] = None, **kwargs ): """ :keyword name: Gets or sets the name of the activity parameter set. @@ -294,12 +284,12 @@ def __init__( :keyword parameters: Gets or sets the parameters of the activity parameter set. :paramtype parameters: list[~azure.mgmt.automation.models.ActivityParameter] """ - super(ActivityParameterSet, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.parameters = parameters -class ActivityParameterValidationSet(msrest.serialization.Model): +class ActivityParameterValidationSet(_serialization.Model): """Definition of the activity parameter validation set. :ivar member_value: Gets or sets the name of the activity parameter validation set member. @@ -307,24 +297,19 @@ class ActivityParameterValidationSet(msrest.serialization.Model): """ _attribute_map = { - 'member_value': {'key': 'memberValue', 'type': 'str'}, + "member_value": {"key": "memberValue", "type": "str"}, } - def __init__( - self, - *, - member_value: Optional[str] = None, - **kwargs - ): + def __init__(self, *, member_value: Optional[str] = None, **kwargs): """ :keyword member_value: Gets or sets the name of the activity parameter validation set member. :paramtype member_value: str """ - super(ActivityParameterValidationSet, self).__init__(**kwargs) + super().__init__(**kwargs) self.member_value = member_value -class AdvancedSchedule(msrest.serialization.Model): +class AdvancedSchedule(_serialization.Model): """The properties of the create Advanced Schedule. :ivar week_days: Days of the week that the job should execute on. @@ -337,9 +322,9 @@ class AdvancedSchedule(msrest.serialization.Model): """ _attribute_map = { - 'week_days': {'key': 'weekDays', 'type': '[str]'}, - 'month_days': {'key': 'monthDays', 'type': '[int]'}, - 'monthly_occurrences': {'key': 'monthlyOccurrences', 'type': '[AdvancedScheduleMonthlyOccurrence]'}, + "week_days": {"key": "weekDays", "type": "[str]"}, + "month_days": {"key": "monthDays", "type": "[int]"}, + "monthly_occurrences": {"key": "monthlyOccurrences", "type": "[AdvancedScheduleMonthlyOccurrence]"}, } def __init__( @@ -360,49 +345,45 @@ def __init__( :paramtype monthly_occurrences: list[~azure.mgmt.automation.models.AdvancedScheduleMonthlyOccurrence] """ - super(AdvancedSchedule, self).__init__(**kwargs) + super().__init__(**kwargs) self.week_days = week_days self.month_days = month_days self.monthly_occurrences = monthly_occurrences -class AdvancedScheduleMonthlyOccurrence(msrest.serialization.Model): +class AdvancedScheduleMonthlyOccurrence(_serialization.Model): """The properties of the create advanced schedule monthly occurrence. :ivar occurrence: Occurrence of the week within the month. Must be between 1 and 5. :vartype occurrence: int :ivar day: Day of the occurrence. Must be one of monday, tuesday, wednesday, thursday, friday, saturday, sunday. Known values are: "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", - "Saturday", "Sunday". + "Saturday", and "Sunday". :vartype day: str or ~azure.mgmt.automation.models.ScheduleDay """ _attribute_map = { - 'occurrence': {'key': 'occurrence', 'type': 'int'}, - 'day': {'key': 'day', 'type': 'str'}, + "occurrence": {"key": "occurrence", "type": "int"}, + "day": {"key": "day", "type": "str"}, } def __init__( - self, - *, - occurrence: Optional[int] = None, - day: Optional[Union[str, "_models.ScheduleDay"]] = None, - **kwargs + self, *, occurrence: Optional[int] = None, day: Optional[Union[str, "_models.ScheduleDay"]] = None, **kwargs ): """ :keyword occurrence: Occurrence of the week within the month. Must be between 1 and 5. :paramtype occurrence: int :keyword day: Day of the occurrence. Must be one of monday, tuesday, wednesday, thursday, friday, saturday, sunday. Known values are: "Monday", "Tuesday", "Wednesday", "Thursday", - "Friday", "Saturday", "Sunday". + "Friday", "Saturday", and "Sunday". :paramtype day: str or ~azure.mgmt.automation.models.ScheduleDay """ - super(AdvancedScheduleMonthlyOccurrence, self).__init__(**kwargs) + super().__init__(**kwargs) self.occurrence = occurrence self.day = day -class AgentRegistration(msrest.serialization.Model): +class AgentRegistration(_serialization.Model): """Definition of the agent registration information type. :ivar dsc_meta_configuration: Gets or sets the dsc meta configuration. @@ -416,10 +397,10 @@ class AgentRegistration(msrest.serialization.Model): """ _attribute_map = { - 'dsc_meta_configuration': {'key': 'dscMetaConfiguration', 'type': 'str'}, - 'endpoint': {'key': 'endpoint', 'type': 'str'}, - 'keys': {'key': 'keys', 'type': 'AgentRegistrationKeys'}, - 'id': {'key': 'id', 'type': 'str'}, + "dsc_meta_configuration": {"key": "dscMetaConfiguration", "type": "str"}, + "endpoint": {"key": "endpoint", "type": "str"}, + "keys": {"key": "keys", "type": "AgentRegistrationKeys"}, + "id": {"key": "id", "type": "str"}, } def __init__( @@ -428,7 +409,7 @@ def __init__( dsc_meta_configuration: Optional[str] = None, endpoint: Optional[str] = None, keys: Optional["_models.AgentRegistrationKeys"] = None, - id: Optional[str] = None, + id: Optional[str] = None, # pylint: disable=redefined-builtin **kwargs ): """ @@ -441,14 +422,14 @@ def __init__( :keyword id: Gets or sets the id. :paramtype id: str """ - super(AgentRegistration, self).__init__(**kwargs) + super().__init__(**kwargs) self.dsc_meta_configuration = dsc_meta_configuration self.endpoint = endpoint self.keys = keys self.id = id -class AgentRegistrationKeys(msrest.serialization.Model): +class AgentRegistrationKeys(_serialization.Model): """Definition of the agent registration keys. :ivar primary: Gets or sets the primary key. @@ -458,62 +439,51 @@ class AgentRegistrationKeys(msrest.serialization.Model): """ _attribute_map = { - 'primary': {'key': 'primary', 'type': 'str'}, - 'secondary': {'key': 'secondary', 'type': 'str'}, + "primary": {"key": "primary", "type": "str"}, + "secondary": {"key": "secondary", "type": "str"}, } - def __init__( - self, - *, - primary: Optional[str] = None, - secondary: Optional[str] = None, - **kwargs - ): + def __init__(self, *, primary: Optional[str] = None, secondary: Optional[str] = None, **kwargs): """ :keyword primary: Gets or sets the primary key. :paramtype primary: str :keyword secondary: Gets or sets the secondary key. :paramtype secondary: str """ - super(AgentRegistrationKeys, self).__init__(**kwargs) + super().__init__(**kwargs) self.primary = primary self.secondary = secondary -class AgentRegistrationRegenerateKeyParameter(msrest.serialization.Model): +class AgentRegistrationRegenerateKeyParameter(_serialization.Model): """The parameters supplied to the regenerate keys operation. All required parameters must be populated in order to send to Azure. - :ivar key_name: Required. Gets or sets the agent registration key name - primary or secondary. - Known values are: "primary", "secondary". + :ivar key_name: Gets or sets the agent registration key name - primary or secondary. Required. + Known values are: "primary" and "secondary". :vartype key_name: str or ~azure.mgmt.automation.models.AgentRegistrationKeyName """ _validation = { - 'key_name': {'required': True}, + "key_name": {"required": True}, } _attribute_map = { - 'key_name': {'key': 'keyName', 'type': 'str'}, + "key_name": {"key": "keyName", "type": "str"}, } - def __init__( - self, - *, - key_name: Union[str, "_models.AgentRegistrationKeyName"], - **kwargs - ): + def __init__(self, *, key_name: Union[str, "_models.AgentRegistrationKeyName"], **kwargs): """ - :keyword key_name: Required. Gets or sets the agent registration key name - primary or - secondary. Known values are: "primary", "secondary". + :keyword key_name: Gets or sets the agent registration key name - primary or secondary. + Required. Known values are: "primary" and "secondary". :paramtype key_name: str or ~azure.mgmt.automation.models.AgentRegistrationKeyName """ - super(AgentRegistrationRegenerateKeyParameter, self).__init__(**kwargs) + super().__init__(**kwargs) self.key_name = key_name -class Resource(msrest.serialization.Model): +class Resource(_serialization.Model): """The core properties of ARM resources. Variables are only populated by the server, and will be ignored when sending a request. @@ -527,24 +497,20 @@ class Resource(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(Resource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -561,45 +527,39 @@ class TrackedResource(Resource): :vartype name: str :ivar type: The type of the resource. :vartype type: str - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar location: The Azure Region where the resource lives. :vartype location: str """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'location': {'key': 'location', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "location": {"key": "location", "type": "str"}, } - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - location: Optional[str] = None, - **kwargs - ): + def __init__(self, *, tags: Optional[Dict[str, str]] = None, location: Optional[str] = None, **kwargs): """ - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword location: The Azure Region where the resource lives. :paramtype location: str """ - super(TrackedResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.location = location -class AutomationAccount(TrackedResource): +class AutomationAccount(TrackedResource): # pylint: disable=too-many-instance-attributes """Definition of the automation account type. Variables are only populated by the server, and will be ignored when sending a request. @@ -610,7 +570,7 @@ class AutomationAccount(TrackedResource): :vartype name: str :ivar type: The type of the resource. :vartype type: str - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar location: The Azure Region where the resource lives. :vartype location: str @@ -624,7 +584,7 @@ class AutomationAccount(TrackedResource): :vartype sku: ~azure.mgmt.automation.models.Sku :ivar last_modified_by: Gets or sets the last modified by. :vartype last_modified_by: str - :ivar state: Gets status of account. Known values are: "Ok", "Unavailable", "Suspended". + :ivar state: Gets status of account. Known values are: "Ok", "Unavailable", and "Suspended". :vartype state: str or ~azure.mgmt.automation.models.AutomationAccountState :ivar creation_time: Gets the creation time. :vartype creation_time: ~datetime.datetime @@ -649,35 +609,38 @@ class AutomationAccount(TrackedResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, - 'state': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'last_modified_time': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'location': {'key': 'location', 'type': 'str'}, - 'etag': {'key': 'etag', 'type': 'str'}, - 'identity': {'key': 'identity', 'type': 'Identity'}, - 'system_data': {'key': 'systemData', 'type': 'SystemData'}, - 'sku': {'key': 'properties.sku', 'type': 'Sku'}, - 'last_modified_by': {'key': 'properties.lastModifiedBy', 'type': 'str'}, - 'state': {'key': 'properties.state', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'encryption': {'key': 'properties.encryption', 'type': 'EncryptionProperties'}, - 'private_endpoint_connections': {'key': 'properties.privateEndpointConnections', 'type': '[PrivateEndpointConnection]'}, - 'public_network_access': {'key': 'properties.publicNetworkAccess', 'type': 'bool'}, - 'disable_local_auth': {'key': 'properties.disableLocalAuth', 'type': 'bool'}, - 'automation_hybrid_service_url': {'key': 'properties.automationHybridServiceUrl', 'type': 'str'}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, + "state": {"readonly": True}, + "creation_time": {"readonly": True}, + "last_modified_time": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "location": {"key": "location", "type": "str"}, + "etag": {"key": "etag", "type": "str"}, + "identity": {"key": "identity", "type": "Identity"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "sku": {"key": "properties.sku", "type": "Sku"}, + "last_modified_by": {"key": "properties.lastModifiedBy", "type": "str"}, + "state": {"key": "properties.state", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, + "encryption": {"key": "properties.encryption", "type": "EncryptionProperties"}, + "private_endpoint_connections": { + "key": "properties.privateEndpointConnections", + "type": "[PrivateEndpointConnection]", + }, + "public_network_access": {"key": "properties.publicNetworkAccess", "type": "bool"}, + "disable_local_auth": {"key": "properties.disableLocalAuth", "type": "bool"}, + "automation_hybrid_service_url": {"key": "properties.automationHybridServiceUrl", "type": "str"}, } def __init__( @@ -698,7 +661,7 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword location: The Azure Region where the resource lives. :paramtype location: str @@ -728,7 +691,7 @@ def __init__( hybrid worker on-boarding. :paramtype automation_hybrid_service_url: str """ - super(AutomationAccount, self).__init__(tags=tags, location=location, **kwargs) + super().__init__(tags=tags, location=location, **kwargs) self.etag = etag self.identity = identity self.system_data = None @@ -745,7 +708,7 @@ def __init__( self.automation_hybrid_service_url = automation_hybrid_service_url -class AutomationAccountCreateOrUpdateParameters(msrest.serialization.Model): +class AutomationAccountCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update automation account operation. :ivar name: Gets or sets name of the resource. @@ -754,7 +717,7 @@ class AutomationAccountCreateOrUpdateParameters(msrest.serialization.Model): :vartype location: str :ivar identity: Sets the identity property for automation account. :vartype identity: ~azure.mgmt.automation.models.Identity - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] :ivar sku: Gets or sets account SKU. :vartype sku: ~azure.mgmt.automation.models.Sku @@ -768,14 +731,14 @@ class AutomationAccountCreateOrUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'location': {'key': 'location', 'type': 'str'}, - 'identity': {'key': 'identity', 'type': 'Identity'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'sku': {'key': 'properties.sku', 'type': 'Sku'}, - 'encryption': {'key': 'properties.encryption', 'type': 'EncryptionProperties'}, - 'public_network_access': {'key': 'properties.publicNetworkAccess', 'type': 'bool'}, - 'disable_local_auth': {'key': 'properties.disableLocalAuth', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "identity": {"key": "identity", "type": "Identity"}, + "tags": {"key": "tags", "type": "{str}"}, + "sku": {"key": "properties.sku", "type": "Sku"}, + "encryption": {"key": "properties.encryption", "type": "EncryptionProperties"}, + "public_network_access": {"key": "properties.publicNetworkAccess", "type": "bool"}, + "disable_local_auth": {"key": "properties.disableLocalAuth", "type": "bool"}, } def __init__( @@ -798,7 +761,7 @@ def __init__( :paramtype location: str :keyword identity: Sets the identity property for automation account. :paramtype identity: ~azure.mgmt.automation.models.Identity - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] :keyword sku: Gets or sets account SKU. :paramtype sku: ~azure.mgmt.automation.models.Sku @@ -811,7 +774,7 @@ def __init__( blocked. :paramtype disable_local_auth: bool """ - super(AutomationAccountCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.location = location self.identity = identity @@ -822,7 +785,7 @@ def __init__( self.disable_local_auth = disable_local_auth -class AutomationAccountListResult(msrest.serialization.Model): +class AutomationAccountListResult(_serialization.Model): """The response model for the list account operation. :ivar value: Gets or sets list of accounts. @@ -832,16 +795,12 @@ class AutomationAccountListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[AutomationAccount]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[AutomationAccount]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.AutomationAccount"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.AutomationAccount"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets list of accounts. @@ -849,12 +808,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(AutomationAccountListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class AutomationAccountUpdateParameters(msrest.serialization.Model): +class AutomationAccountUpdateParameters(_serialization.Model): """The parameters supplied to the update automation account operation. :ivar name: Gets or sets the name of the resource. @@ -863,7 +822,7 @@ class AutomationAccountUpdateParameters(msrest.serialization.Model): :vartype location: str :ivar identity: Sets the identity property for automation account. :vartype identity: ~azure.mgmt.automation.models.Identity - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] :ivar sku: Gets or sets account SKU. :vartype sku: ~azure.mgmt.automation.models.Sku @@ -877,14 +836,14 @@ class AutomationAccountUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'location': {'key': 'location', 'type': 'str'}, - 'identity': {'key': 'identity', 'type': 'Identity'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'sku': {'key': 'properties.sku', 'type': 'Sku'}, - 'encryption': {'key': 'properties.encryption', 'type': 'EncryptionProperties'}, - 'public_network_access': {'key': 'properties.publicNetworkAccess', 'type': 'bool'}, - 'disable_local_auth': {'key': 'properties.disableLocalAuth', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "identity": {"key": "identity", "type": "Identity"}, + "tags": {"key": "tags", "type": "{str}"}, + "sku": {"key": "properties.sku", "type": "Sku"}, + "encryption": {"key": "properties.encryption", "type": "EncryptionProperties"}, + "public_network_access": {"key": "properties.publicNetworkAccess", "type": "bool"}, + "disable_local_auth": {"key": "properties.disableLocalAuth", "type": "bool"}, } def __init__( @@ -907,7 +866,7 @@ def __init__( :paramtype location: str :keyword identity: Sets the identity property for automation account. :paramtype identity: ~azure.mgmt.automation.models.Identity - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] :keyword sku: Gets or sets account SKU. :paramtype sku: ~azure.mgmt.automation.models.Sku @@ -920,7 +879,7 @@ def __init__( blocked. :paramtype disable_local_auth: bool """ - super(AutomationAccountUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.location = location self.identity = identity @@ -931,7 +890,7 @@ def __init__( self.disable_local_auth = disable_local_auth -class AzureQueryProperties(msrest.serialization.Model): +class AzureQueryProperties(_serialization.Model): """Azure query for the update configuration. :ivar scope: List of Subscription or Resource Group ARM Ids. @@ -943,9 +902,9 @@ class AzureQueryProperties(msrest.serialization.Model): """ _attribute_map = { - 'scope': {'key': 'scope', 'type': '[str]'}, - 'locations': {'key': 'locations', 'type': '[str]'}, - 'tag_settings': {'key': 'tagSettings', 'type': 'TagSettingsProperties'}, + "scope": {"key": "scope", "type": "[str]"}, + "locations": {"key": "locations", "type": "[str]"}, + "tag_settings": {"key": "tagSettings", "type": "TagSettingsProperties"}, } def __init__( @@ -964,7 +923,7 @@ def __init__( :keyword tag_settings: Tag settings for the VM. :paramtype tag_settings: ~azure.mgmt.automation.models.TagSettingsProperties """ - super(AzureQueryProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.scope = scope self.locations = locations self.tag_settings = tag_settings @@ -984,24 +943,20 @@ class ProxyResource(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(ProxyResource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) class Certificate(ProxyResource): @@ -1030,39 +985,34 @@ class Certificate(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'thumbprint': {'readonly': True}, - 'expiry_time': {'readonly': True}, - 'is_exportable': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'last_modified_time': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "thumbprint": {"readonly": True}, + "expiry_time": {"readonly": True}, + "is_exportable": {"readonly": True}, + "creation_time": {"readonly": True}, + "last_modified_time": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'thumbprint': {'key': 'properties.thumbprint', 'type': 'str'}, - 'expiry_time': {'key': 'properties.expiryTime', 'type': 'iso-8601'}, - 'is_exportable': {'key': 'properties.isExportable', 'type': 'bool'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "thumbprint": {"key": "properties.thumbprint", "type": "str"}, + "expiry_time": {"key": "properties.expiryTime", "type": "iso-8601"}, + "is_exportable": {"key": "properties.isExportable", "type": "bool"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, } - def __init__( - self, - *, - description: Optional[str] = None, - **kwargs - ): + def __init__(self, *, description: Optional[str] = None, **kwargs): """ :keyword description: Gets or sets the description. :paramtype description: str """ - super(Certificate, self).__init__(**kwargs) + super().__init__(**kwargs) self.thumbprint = None self.expiry_time = None self.is_exportable = None @@ -1071,14 +1021,14 @@ def __init__( self.description = description -class CertificateCreateOrUpdateParameters(msrest.serialization.Model): +class CertificateCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update or replace certificate operation. All required parameters must be populated in order to send to Azure. - :ivar name: Required. Gets or sets the name of the certificate. + :ivar name: Gets or sets the name of the certificate. Required. :vartype name: str - :ivar base64_value: Required. Gets or sets the base64 encoded value of the certificate. + :ivar base64_value: Gets or sets the base64 encoded value of the certificate. Required. :vartype base64_value: str :ivar description: Gets or sets the description of the certificate. :vartype description: str @@ -1089,16 +1039,16 @@ class CertificateCreateOrUpdateParameters(msrest.serialization.Model): """ _validation = { - 'name': {'required': True}, - 'base64_value': {'required': True}, + "name": {"required": True}, + "base64_value": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'base64_value': {'key': 'properties.base64Value', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'thumbprint': {'key': 'properties.thumbprint', 'type': 'str'}, - 'is_exportable': {'key': 'properties.isExportable', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "base64_value": {"key": "properties.base64Value", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, + "thumbprint": {"key": "properties.thumbprint", "type": "str"}, + "is_exportable": {"key": "properties.isExportable", "type": "bool"}, } def __init__( @@ -1112,9 +1062,9 @@ def __init__( **kwargs ): """ - :keyword name: Required. Gets or sets the name of the certificate. + :keyword name: Gets or sets the name of the certificate. Required. :paramtype name: str - :keyword base64_value: Required. Gets or sets the base64 encoded value of the certificate. + :keyword base64_value: Gets or sets the base64 encoded value of the certificate. Required. :paramtype base64_value: str :keyword description: Gets or sets the description of the certificate. :paramtype description: str @@ -1123,7 +1073,7 @@ def __init__( :keyword is_exportable: Gets or sets the is exportable flag of the certificate. :paramtype is_exportable: bool """ - super(CertificateCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.base64_value = base64_value self.description = description @@ -1131,7 +1081,7 @@ def __init__( self.is_exportable = is_exportable -class CertificateListResult(msrest.serialization.Model): +class CertificateListResult(_serialization.Model): """The response model for the list certificate operation. :ivar value: Gets or sets a list of certificates. @@ -1141,16 +1091,12 @@ class CertificateListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Certificate]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Certificate]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.Certificate"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.Certificate"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets a list of certificates. @@ -1158,12 +1104,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(CertificateListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class CertificateUpdateParameters(msrest.serialization.Model): +class CertificateUpdateParameters(_serialization.Model): """The parameters supplied to the update certificate operation. :ivar name: Gets or sets the name of the certificate. @@ -1173,60 +1119,22 @@ class CertificateUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - description: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, description: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the certificate. :paramtype name: str :keyword description: Gets or sets the description of the certificate. :paramtype description: str """ - super(CertificateUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.description = description -class ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties(msrest.serialization.Model): - """ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar principal_id: The principal id of user assigned identity. - :vartype principal_id: str - :ivar client_id: The client id of user assigned identity. - :vartype client_id: str - """ - - _validation = { - 'principal_id': {'readonly': True}, - 'client_id': {'readonly': True}, - } - - _attribute_map = { - 'principal_id': {'key': 'principalId', 'type': 'str'}, - 'client_id': {'key': 'clientId', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - """ - """ - super(ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties, self).__init__(**kwargs) - self.principal_id = None - self.client_id = None - - class Connection(ProxyResource): """Definition of the connection. @@ -1251,23 +1159,23 @@ class Connection(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'field_definition_values': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'last_modified_time': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "field_definition_values": {"readonly": True}, + "creation_time": {"readonly": True}, + "last_modified_time": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'connection_type': {'key': 'properties.connectionType', 'type': 'ConnectionTypeAssociationProperty'}, - 'field_definition_values': {'key': 'properties.fieldDefinitionValues', 'type': '{str}'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "connection_type": {"key": "properties.connectionType", "type": "ConnectionTypeAssociationProperty"}, + "field_definition_values": {"key": "properties.fieldDefinitionValues", "type": "{str}"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -1283,7 +1191,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(Connection, self).__init__(**kwargs) + super().__init__(**kwargs) self.connection_type = connection_type self.field_definition_values = None self.creation_time = None @@ -1291,31 +1199,31 @@ def __init__( self.description = description -class ConnectionCreateOrUpdateParameters(msrest.serialization.Model): +class ConnectionCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update connection operation. All required parameters must be populated in order to send to Azure. - :ivar name: Required. Gets or sets the name of the connection. + :ivar name: Gets or sets the name of the connection. Required. :vartype name: str :ivar description: Gets or sets the description of the connection. :vartype description: str - :ivar connection_type: Required. Gets or sets the connectionType of the connection. + :ivar connection_type: Gets or sets the connectionType of the connection. Required. :vartype connection_type: ~azure.mgmt.automation.models.ConnectionTypeAssociationProperty :ivar field_definition_values: Gets or sets the field definition properties of the connection. :vartype field_definition_values: dict[str, str] """ _validation = { - 'name': {'required': True}, - 'connection_type': {'required': True}, + "name": {"required": True}, + "connection_type": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'connection_type': {'key': 'properties.connectionType', 'type': 'ConnectionTypeAssociationProperty'}, - 'field_definition_values': {'key': 'properties.fieldDefinitionValues', 'type': '{str}'}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, + "connection_type": {"key": "properties.connectionType", "type": "ConnectionTypeAssociationProperty"}, + "field_definition_values": {"key": "properties.fieldDefinitionValues", "type": "{str}"}, } def __init__( @@ -1328,24 +1236,24 @@ def __init__( **kwargs ): """ - :keyword name: Required. Gets or sets the name of the connection. + :keyword name: Gets or sets the name of the connection. Required. :paramtype name: str :keyword description: Gets or sets the description of the connection. :paramtype description: str - :keyword connection_type: Required. Gets or sets the connectionType of the connection. + :keyword connection_type: Gets or sets the connectionType of the connection. Required. :paramtype connection_type: ~azure.mgmt.automation.models.ConnectionTypeAssociationProperty :keyword field_definition_values: Gets or sets the field definition properties of the connection. :paramtype field_definition_values: dict[str, str] """ - super(ConnectionCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.description = description self.connection_type = connection_type self.field_definition_values = field_definition_values -class ConnectionListResult(msrest.serialization.Model): +class ConnectionListResult(_serialization.Model): """The response model for the list connection operation. :ivar value: Gets or sets a list of connection. @@ -1355,16 +1263,12 @@ class ConnectionListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Connection]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Connection]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.Connection"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.Connection"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets a list of connection. @@ -1372,12 +1276,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(ConnectionListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ConnectionType(msrest.serialization.Model): +class ConnectionType(_serialization.Model): """Definition of the connection type. Variables are only populated by the server, and will be ignored when sending a request. @@ -1401,22 +1305,22 @@ class ConnectionType(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'field_definitions': {'readonly': True}, - 'creation_time': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "field_definitions": {"readonly": True}, + "creation_time": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'is_global': {'key': 'properties.isGlobal', 'type': 'bool'}, - 'field_definitions': {'key': 'properties.fieldDefinitions', 'type': '{FieldDefinition}'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "is_global": {"key": "properties.isGlobal", "type": "bool"}, + "field_definitions": {"key": "properties.fieldDefinitions", "type": "{FieldDefinition}"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -1435,7 +1339,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(ConnectionType, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -1446,7 +1350,7 @@ def __init__( self.description = description -class ConnectionTypeAssociationProperty(msrest.serialization.Model): +class ConnectionTypeAssociationProperty(_serialization.Model): """The connection type property associated with the entity. :ivar name: Gets or sets the name of the connection type. @@ -1454,45 +1358,40 @@ class ConnectionTypeAssociationProperty(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the connection type. :paramtype name: str """ - super(ConnectionTypeAssociationProperty, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class ConnectionTypeCreateOrUpdateParameters(msrest.serialization.Model): +class ConnectionTypeCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update connection type operation. All required parameters must be populated in order to send to Azure. - :ivar name: Required. Gets or sets the name of the connection type. + :ivar name: Gets or sets the name of the connection type. Required. :vartype name: str :ivar is_global: Gets or sets a Boolean value to indicate if the connection type is global. :vartype is_global: bool - :ivar field_definitions: Required. Gets or sets the field definitions of the connection type. + :ivar field_definitions: Gets or sets the field definitions of the connection type. Required. :vartype field_definitions: dict[str, ~azure.mgmt.automation.models.FieldDefinition] """ _validation = { - 'name': {'required': True}, - 'field_definitions': {'required': True}, + "name": {"required": True}, + "field_definitions": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'is_global': {'key': 'properties.isGlobal', 'type': 'bool'}, - 'field_definitions': {'key': 'properties.fieldDefinitions', 'type': '{FieldDefinition}'}, + "name": {"key": "name", "type": "str"}, + "is_global": {"key": "properties.isGlobal", "type": "bool"}, + "field_definitions": {"key": "properties.fieldDefinitions", "type": "{FieldDefinition}"}, } def __init__( @@ -1504,21 +1403,21 @@ def __init__( **kwargs ): """ - :keyword name: Required. Gets or sets the name of the connection type. + :keyword name: Gets or sets the name of the connection type. Required. :paramtype name: str :keyword is_global: Gets or sets a Boolean value to indicate if the connection type is global. :paramtype is_global: bool - :keyword field_definitions: Required. Gets or sets the field definitions of the connection - type. + :keyword field_definitions: Gets or sets the field definitions of the connection type. + Required. :paramtype field_definitions: dict[str, ~azure.mgmt.automation.models.FieldDefinition] """ - super(ConnectionTypeCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.is_global = is_global self.field_definitions = field_definitions -class ConnectionTypeListResult(msrest.serialization.Model): +class ConnectionTypeListResult(_serialization.Model): """The response model for the list connection type operation. :ivar value: Gets or sets a list of connection types. @@ -1528,16 +1427,12 @@ class ConnectionTypeListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[ConnectionType]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[ConnectionType]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.ConnectionType"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.ConnectionType"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets a list of connection types. @@ -1545,12 +1440,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(ConnectionTypeListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ConnectionUpdateParameters(msrest.serialization.Model): +class ConnectionUpdateParameters(_serialization.Model): """The parameters supplied to the update connection operation. :ivar name: Gets or sets the name of the connection. @@ -1562,9 +1457,9 @@ class ConnectionUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'field_definition_values': {'key': 'properties.fieldDefinitionValues', 'type': '{str}'}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, + "field_definition_values": {"key": "properties.fieldDefinitionValues", "type": "{str}"}, } def __init__( @@ -1583,52 +1478,46 @@ def __init__( :keyword field_definition_values: Gets or sets the field definition values of the connection. :paramtype field_definition_values: dict[str, str] """ - super(ConnectionUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.description = description self.field_definition_values = field_definition_values -class ContentHash(msrest.serialization.Model): +class ContentHash(_serialization.Model): """Definition of the runbook property type. All required parameters must be populated in order to send to Azure. - :ivar algorithm: Required. Gets or sets the content hash algorithm used to hash the content. + :ivar algorithm: Gets or sets the content hash algorithm used to hash the content. Required. :vartype algorithm: str - :ivar value: Required. Gets or sets expected hash value of the content. + :ivar value: Gets or sets expected hash value of the content. Required. :vartype value: str """ _validation = { - 'algorithm': {'required': True}, - 'value': {'required': True}, + "algorithm": {"required": True}, + "value": {"required": True}, } _attribute_map = { - 'algorithm': {'key': 'algorithm', 'type': 'str'}, - 'value': {'key': 'value', 'type': 'str'}, + "algorithm": {"key": "algorithm", "type": "str"}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - algorithm: str, - value: str, - **kwargs - ): + def __init__(self, *, algorithm: str, value: str, **kwargs): """ - :keyword algorithm: Required. Gets or sets the content hash algorithm used to hash the content. + :keyword algorithm: Gets or sets the content hash algorithm used to hash the content. Required. :paramtype algorithm: str - :keyword value: Required. Gets or sets expected hash value of the content. + :keyword value: Gets or sets expected hash value of the content. Required. :paramtype value: str """ - super(ContentHash, self).__init__(**kwargs) + super().__init__(**kwargs) self.algorithm = algorithm self.value = value -class ContentLink(msrest.serialization.Model): +class ContentLink(_serialization.Model): """Definition of the content link. :ivar uri: Gets or sets the uri of the runbook content. @@ -1640,9 +1529,9 @@ class ContentLink(msrest.serialization.Model): """ _attribute_map = { - 'uri': {'key': 'uri', 'type': 'str'}, - 'content_hash': {'key': 'contentHash', 'type': 'ContentHash'}, - 'version': {'key': 'version', 'type': 'str'}, + "uri": {"key": "uri", "type": "str"}, + "content_hash": {"key": "contentHash", "type": "ContentHash"}, + "version": {"key": "version", "type": "str"}, } def __init__( @@ -1661,18 +1550,19 @@ def __init__( :keyword version: Gets or sets the version of the content. :paramtype version: str """ - super(ContentLink, self).__init__(**kwargs) + super().__init__(**kwargs) self.uri = uri self.content_hash = content_hash self.version = version -class ContentSource(msrest.serialization.Model): +class ContentSource(_serialization.Model): """Definition of the content source. :ivar hash: Gets or sets the hash. :vartype hash: ~azure.mgmt.automation.models.ContentHash - :ivar type: Gets or sets the content source type. Known values are: "embeddedContent", "uri". + :ivar type: Gets or sets the content source type. Known values are: "embeddedContent" and + "uri". :vartype type: str or ~azure.mgmt.automation.models.ContentSourceType :ivar value: Gets or sets the value of the content. This is based on the content source type. :vartype value: str @@ -1681,10 +1571,10 @@ class ContentSource(msrest.serialization.Model): """ _attribute_map = { - 'hash': {'key': 'hash', 'type': 'ContentHash'}, - 'type': {'key': 'type', 'type': 'str'}, - 'value': {'key': 'value', 'type': 'str'}, - 'version': {'key': 'version', 'type': 'str'}, + "hash": {"key": "hash", "type": "ContentHash"}, + "type": {"key": "type", "type": "str"}, + "value": {"key": "value", "type": "str"}, + "version": {"key": "version", "type": "str"}, } def __init__( @@ -1699,7 +1589,7 @@ def __init__( """ :keyword hash: Gets or sets the hash. :paramtype hash: ~azure.mgmt.automation.models.ContentHash - :keyword type: Gets or sets the content source type. Known values are: "embeddedContent", + :keyword type: Gets or sets the content source type. Known values are: "embeddedContent" and "uri". :paramtype type: str or ~azure.mgmt.automation.models.ContentSourceType :keyword value: Gets or sets the value of the content. This is based on the content source @@ -1708,7 +1598,7 @@ def __init__( :keyword version: Gets or sets the version of the content. :paramtype version: str """ - super(ContentSource, self).__init__(**kwargs) + super().__init__(**kwargs) self.hash = hash self.type = type self.value = value @@ -1737,96 +1627,83 @@ class Credential(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'user_name': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'last_modified_time': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "user_name": {"readonly": True}, + "creation_time": {"readonly": True}, + "last_modified_time": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'user_name': {'key': 'properties.userName', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "user_name": {"key": "properties.userName", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, } - def __init__( - self, - *, - description: Optional[str] = None, - **kwargs - ): + def __init__(self, *, description: Optional[str] = None, **kwargs): """ :keyword description: Gets or sets the description. :paramtype description: str """ - super(Credential, self).__init__(**kwargs) + super().__init__(**kwargs) self.user_name = None self.creation_time = None self.last_modified_time = None self.description = description -class CredentialCreateOrUpdateParameters(msrest.serialization.Model): +class CredentialCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update credential operation. All required parameters must be populated in order to send to Azure. - :ivar name: Required. Gets or sets the name of the credential. + :ivar name: Gets or sets the name of the credential. Required. :vartype name: str - :ivar user_name: Required. Gets or sets the user name of the credential. + :ivar user_name: Gets or sets the user name of the credential. Required. :vartype user_name: str - :ivar password: Required. Gets or sets the password of the credential. + :ivar password: Gets or sets the password of the credential. Required. :vartype password: str :ivar description: Gets or sets the description of the credential. :vartype description: str """ _validation = { - 'name': {'required': True}, - 'user_name': {'required': True}, - 'password': {'required': True}, + "name": {"required": True}, + "user_name": {"required": True}, + "password": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'user_name': {'key': 'properties.userName', 'type': 'str'}, - 'password': {'key': 'properties.password', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "user_name": {"key": "properties.userName", "type": "str"}, + "password": {"key": "properties.password", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, } - def __init__( - self, - *, - name: str, - user_name: str, - password: str, - description: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: str, user_name: str, password: str, description: Optional[str] = None, **kwargs): """ - :keyword name: Required. Gets or sets the name of the credential. + :keyword name: Gets or sets the name of the credential. Required. :paramtype name: str - :keyword user_name: Required. Gets or sets the user name of the credential. + :keyword user_name: Gets or sets the user name of the credential. Required. :paramtype user_name: str - :keyword password: Required. Gets or sets the password of the credential. + :keyword password: Gets or sets the password of the credential. Required. :paramtype password: str :keyword description: Gets or sets the description of the credential. :paramtype description: str """ - super(CredentialCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.user_name = user_name self.password = password self.description = description -class CredentialListResult(msrest.serialization.Model): +class CredentialListResult(_serialization.Model): """The response model for the list credential operation. :ivar value: Gets or sets a list of credentials. @@ -1836,16 +1713,12 @@ class CredentialListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Credential]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Credential]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.Credential"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.Credential"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets a list of credentials. @@ -1853,12 +1726,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(CredentialListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class CredentialUpdateParameters(msrest.serialization.Model): +class CredentialUpdateParameters(_serialization.Model): """The parameters supplied to the Update credential operation. :ivar name: Gets or sets the name of the credential. @@ -1872,10 +1745,10 @@ class CredentialUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'user_name': {'key': 'properties.userName', 'type': 'str'}, - 'password': {'key': 'properties.password', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "user_name": {"key": "properties.userName", "type": "str"}, + "password": {"key": "properties.password", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -1897,14 +1770,137 @@ def __init__( :keyword description: Gets or sets the description of the credential. :paramtype description: str """ - super(CredentialUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.user_name = user_name self.password = password self.description = description -class DscCompilationJob(ProxyResource): +class DeletedAutomationAccount(_serialization.Model): + """Definition of the deleted automation account type. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar id: The resource id. + :vartype id: str + :ivar name: Gets or sets name of the resource. + :vartype name: str + :ivar type: The resource type. + :vartype type: str + :ivar location: Gets or sets the location of the resource. + :vartype location: str + :ivar automation_account_resource_id: Gets or sets the Automation Account Resource Id. + :vartype automation_account_resource_id: str + :ivar automation_account_id: Gets or sets the Automation Account Id. + :vartype automation_account_id: str + :ivar location_properties_location: Gets or sets the location of the resource. + :vartype location_properties_location: str + :ivar deletion_time: Gets the deletion time. + :vartype deletion_time: ~datetime.datetime + """ + + _validation = { + "deletion_time": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "automation_account_resource_id": {"key": "properties.automationAccountResourceId", "type": "str"}, + "automation_account_id": {"key": "properties.automationAccountId", "type": "str"}, + "location_properties_location": {"key": "properties.location", "type": "str"}, + "deletion_time": {"key": "properties.deletionTime", "type": "iso-8601"}, + } + + def __init__( + self, + *, + id: Optional[str] = None, # pylint: disable=redefined-builtin + name: Optional[str] = None, + type: Optional[str] = None, + location: Optional[str] = None, + automation_account_resource_id: Optional[str] = None, + automation_account_id: Optional[str] = None, + location_properties_location: Optional[str] = None, + **kwargs + ): + """ + :keyword id: The resource id. + :paramtype id: str + :keyword name: Gets or sets name of the resource. + :paramtype name: str + :keyword type: The resource type. + :paramtype type: str + :keyword location: Gets or sets the location of the resource. + :paramtype location: str + :keyword automation_account_resource_id: Gets or sets the Automation Account Resource Id. + :paramtype automation_account_resource_id: str + :keyword automation_account_id: Gets or sets the Automation Account Id. + :paramtype automation_account_id: str + :keyword location_properties_location: Gets or sets the location of the resource. + :paramtype location_properties_location: str + """ + super().__init__(**kwargs) + self.id = id + self.name = name + self.type = type + self.location = location + self.automation_account_resource_id = automation_account_resource_id + self.automation_account_id = automation_account_id + self.location_properties_location = location_properties_location + self.deletion_time = None + + +class DeletedAutomationAccountListResult(_serialization.Model): + """The response model for the list deleted automation account. + + :ivar value: Gets or sets the list of deleted automation accounts. + :vartype value: list[~azure.mgmt.automation.models.DeletedAutomationAccount] + """ + + _attribute_map = { + "value": {"key": "value", "type": "[DeletedAutomationAccount]"}, + } + + def __init__(self, *, value: Optional[List["_models.DeletedAutomationAccount"]] = None, **kwargs): + """ + :keyword value: Gets or sets the list of deleted automation accounts. + :paramtype value: list[~azure.mgmt.automation.models.DeletedAutomationAccount] + """ + super().__init__(**kwargs) + self.value = value + + +class Dimension(_serialization.Model): + """Dimension of the metric. + + :ivar name: The name of the dimension. + :vartype name: str + :ivar display_name: The display name of the dimension. + :vartype display_name: str + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + } + + def __init__(self, *, name: Optional[str] = None, display_name: Optional[str] = None, **kwargs): + """ + :keyword name: The name of the dimension. + :paramtype name: str + :keyword display_name: The display name of the dimension. + :paramtype display_name: str + """ + super().__init__(**kwargs) + self.name = name + self.display_name = display_name + + +class DscCompilationJob(ProxyResource): # pylint: disable=too-many-instance-attributes """Definition of the Dsc Compilation job. Variables are only populated by the server, and will be ignored when sending a request. @@ -1924,14 +1920,14 @@ class DscCompilationJob(ProxyResource): :ivar creation_time: Gets the creation time of the job. :vartype creation_time: ~datetime.datetime :ivar provisioning_state: The current provisioning state of the job. Known values are: - "Failed", "Succeeded", "Suspended", "Processing". + "Failed", "Succeeded", "Suspended", and "Processing". :vartype provisioning_state: str or ~azure.mgmt.automation.models.JobProvisioningState :ivar run_on: Gets or sets the runOn which specifies the group name where the job is to be executed. :vartype run_on: str :ivar status: Gets or sets the status of the job. Known values are: "New", "Activating", "Running", "Completed", "Failed", "Stopped", "Blocked", "Suspended", "Disconnected", - "Suspending", "Stopping", "Resuming", "Removing". + "Suspending", "Stopping", "Resuming", and "Removing". :vartype status: str or ~azure.mgmt.automation.models.JobStatus :ivar status_details: Gets or sets the status details of the job. :vartype status_details: str @@ -1950,37 +1946,37 @@ class DscCompilationJob(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'started_by': {'readonly': True}, - 'job_id': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'start_time': {'readonly': True}, - 'end_time': {'readonly': True}, - 'exception': {'readonly': True}, - 'last_modified_time': {'readonly': True}, - 'last_status_modified_time': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'configuration': {'key': 'properties.configuration', 'type': 'DscConfigurationAssociationProperty'}, - 'started_by': {'key': 'properties.startedBy', 'type': 'str'}, - 'job_id': {'key': 'properties.jobId', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, - 'status': {'key': 'properties.status', 'type': 'str'}, - 'status_details': {'key': 'properties.statusDetails', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'properties.endTime', 'type': 'iso-8601'}, - 'exception': {'key': 'properties.exception', 'type': 'str'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'last_status_modified_time': {'key': 'properties.lastStatusModifiedTime', 'type': 'iso-8601'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "started_by": {"readonly": True}, + "job_id": {"readonly": True}, + "creation_time": {"readonly": True}, + "start_time": {"readonly": True}, + "end_time": {"readonly": True}, + "exception": {"readonly": True}, + "last_modified_time": {"readonly": True}, + "last_status_modified_time": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "configuration": {"key": "properties.configuration", "type": "DscConfigurationAssociationProperty"}, + "started_by": {"key": "properties.startedBy", "type": "str"}, + "job_id": {"key": "properties.jobId", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "run_on": {"key": "properties.runOn", "type": "str"}, + "status": {"key": "properties.status", "type": "str"}, + "status_details": {"key": "properties.statusDetails", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "end_time": {"key": "properties.endTime", "type": "iso-8601"}, + "exception": {"key": "properties.exception", "type": "str"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "last_status_modified_time": {"key": "properties.lastStatusModifiedTime", "type": "iso-8601"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, } def __init__( @@ -1998,21 +1994,21 @@ def __init__( :keyword configuration: Gets or sets the configuration. :paramtype configuration: ~azure.mgmt.automation.models.DscConfigurationAssociationProperty :keyword provisioning_state: The current provisioning state of the job. Known values are: - "Failed", "Succeeded", "Suspended", "Processing". + "Failed", "Succeeded", "Suspended", and "Processing". :paramtype provisioning_state: str or ~azure.mgmt.automation.models.JobProvisioningState :keyword run_on: Gets or sets the runOn which specifies the group name where the job is to be executed. :paramtype run_on: str :keyword status: Gets or sets the status of the job. Known values are: "New", "Activating", "Running", "Completed", "Failed", "Stopped", "Blocked", "Suspended", "Disconnected", - "Suspending", "Stopping", "Resuming", "Removing". + "Suspending", "Stopping", "Resuming", and "Removing". :paramtype status: str or ~azure.mgmt.automation.models.JobStatus :keyword status_details: Gets or sets the status details of the job. :paramtype status_details: str :keyword parameters: Gets or sets the parameters of the job. :paramtype parameters: dict[str, str] """ - super(DscCompilationJob, self).__init__(**kwargs) + super().__init__(**kwargs) self.configuration = configuration self.started_by = None self.job_id = None @@ -2029,7 +2025,7 @@ def __init__( self.parameters = parameters -class DscCompilationJobCreateParameters(msrest.serialization.Model): +class DscCompilationJobCreateParameters(_serialization.Model): """The parameters supplied to the create compilation job operation. All required parameters must be populated in order to send to Azure. @@ -2038,9 +2034,9 @@ class DscCompilationJobCreateParameters(msrest.serialization.Model): :vartype name: str :ivar location: Gets or sets the location of the resource. :vartype location: str - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] - :ivar configuration: Required. Gets or sets the configuration. + :ivar configuration: Gets or sets the configuration. Required. :vartype configuration: ~azure.mgmt.automation.models.DscConfigurationAssociationProperty :ivar parameters: Gets or sets the parameters of the job. :vartype parameters: dict[str, str] @@ -2050,16 +2046,16 @@ class DscCompilationJobCreateParameters(msrest.serialization.Model): """ _validation = { - 'configuration': {'required': True}, + "configuration": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'configuration': {'key': 'properties.configuration', 'type': 'DscConfigurationAssociationProperty'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, - 'increment_node_configuration_build': {'key': 'properties.incrementNodeConfigurationBuild', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "configuration": {"key": "properties.configuration", "type": "DscConfigurationAssociationProperty"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, + "increment_node_configuration_build": {"key": "properties.incrementNodeConfigurationBuild", "type": "bool"}, } def __init__( @@ -2078,9 +2074,9 @@ def __init__( :paramtype name: str :keyword location: Gets or sets the location of the resource. :paramtype location: str - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] - :keyword configuration: Required. Gets or sets the configuration. + :keyword configuration: Gets or sets the configuration. Required. :paramtype configuration: ~azure.mgmt.automation.models.DscConfigurationAssociationProperty :keyword parameters: Gets or sets the parameters of the job. :paramtype parameters: dict[str, str] @@ -2088,7 +2084,7 @@ def __init__( required. :paramtype increment_node_configuration_build: bool """ - super(DscCompilationJobCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.location = location self.tags = tags @@ -2097,7 +2093,7 @@ def __init__( self.increment_node_configuration_build = increment_node_configuration_build -class DscCompilationJobListResult(msrest.serialization.Model): +class DscCompilationJobListResult(_serialization.Model): """The response model for the list job operation. :ivar value: Gets or sets a list of Dsc Compilation jobs. @@ -2107,16 +2103,12 @@ class DscCompilationJobListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DscCompilationJob]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[DscCompilationJob]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.DscCompilationJob"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.DscCompilationJob"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets a list of Dsc Compilation jobs. @@ -2124,12 +2116,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(DscCompilationJobListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DscConfiguration(TrackedResource): +class DscConfiguration(TrackedResource): # pylint: disable=too-many-instance-attributes """Definition of the configuration type. Variables are only populated by the server, and will be ignored when sending a request. @@ -2140,14 +2132,14 @@ class DscConfiguration(TrackedResource): :vartype name: str :ivar type: The type of the resource. :vartype type: str - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar location: The Azure Region where the resource lives. :vartype location: str :ivar etag: Gets or sets the etag of the resource. :vartype etag: str - :ivar provisioning_state: Gets or sets the provisioning state of the configuration. The only - acceptable values to pass in are None and "Succeeded". The default value is None. + :ivar provisioning_state: Gets or sets the provisioning state of the configuration. Default + value is "Succeeded". :vartype provisioning_state: str :ivar job_count: Gets or sets the job count of the configuration. :vartype job_count: int @@ -2155,7 +2147,7 @@ class DscConfiguration(TrackedResource): :vartype parameters: dict[str, ~azure.mgmt.automation.models.DscConfigurationParameter] :ivar source: Gets or sets the source. :vartype source: ~azure.mgmt.automation.models.ContentSource - :ivar state: Gets or sets the state of the configuration. Known values are: "New", "Edit", + :ivar state: Gets or sets the state of the configuration. Known values are: "New", "Edit", and "Published". :vartype state: str or ~azure.mgmt.automation.models.DscConfigurationState :ivar log_verbose: Gets or sets verbose log option. @@ -2171,28 +2163,28 @@ class DscConfiguration(TrackedResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'location': {'key': 'location', 'type': 'str'}, - 'etag': {'key': 'etag', 'type': 'str'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'job_count': {'key': 'properties.jobCount', 'type': 'int'}, - 'parameters': {'key': 'properties.parameters', 'type': '{DscConfigurationParameter}'}, - 'source': {'key': 'properties.source', 'type': 'ContentSource'}, - 'state': {'key': 'properties.state', 'type': 'str'}, - 'log_verbose': {'key': 'properties.logVerbose', 'type': 'bool'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'node_configuration_count': {'key': 'properties.nodeConfigurationCount', 'type': 'int'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "location": {"key": "location", "type": "str"}, + "etag": {"key": "etag", "type": "str"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "job_count": {"key": "properties.jobCount", "type": "int"}, + "parameters": {"key": "properties.parameters", "type": "{DscConfigurationParameter}"}, + "source": {"key": "properties.source", "type": "ContentSource"}, + "state": {"key": "properties.state", "type": "str"}, + "log_verbose": {"key": "properties.logVerbose", "type": "bool"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "node_configuration_count": {"key": "properties.nodeConfigurationCount", "type": "int"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -2214,14 +2206,14 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword location: The Azure Region where the resource lives. :paramtype location: str :keyword etag: Gets or sets the etag of the resource. :paramtype etag: str - :keyword provisioning_state: Gets or sets the provisioning state of the configuration. The only - acceptable values to pass in are None and "Succeeded". The default value is None. + :keyword provisioning_state: Gets or sets the provisioning state of the configuration. Default + value is "Succeeded". :paramtype provisioning_state: str :keyword job_count: Gets or sets the job count of the configuration. :paramtype job_count: int @@ -2230,7 +2222,7 @@ def __init__( :keyword source: Gets or sets the source. :paramtype source: ~azure.mgmt.automation.models.ContentSource :keyword state: Gets or sets the state of the configuration. Known values are: "New", "Edit", - "Published". + and "Published". :paramtype state: str or ~azure.mgmt.automation.models.DscConfigurationState :keyword log_verbose: Gets or sets verbose log option. :paramtype log_verbose: bool @@ -2243,7 +2235,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(DscConfiguration, self).__init__(tags=tags, location=location, **kwargs) + super().__init__(tags=tags, location=location, **kwargs) self.etag = etag self.provisioning_state = provisioning_state self.job_count = job_count @@ -2257,7 +2249,7 @@ def __init__( self.description = description -class DscConfigurationAssociationProperty(msrest.serialization.Model): +class DscConfigurationAssociationProperty(_serialization.Model): """The Dsc configuration property associated with the entity. :ivar name: Gets or sets the name of the Dsc configuration. @@ -2265,24 +2257,19 @@ class DscConfigurationAssociationProperty(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the Dsc configuration. :paramtype name: str """ - super(DscConfigurationAssociationProperty, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class DscConfigurationCreateOrUpdateParameters(msrest.serialization.Model): +class DscConfigurationCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update configuration operation. All required parameters must be populated in order to send to Azure. @@ -2291,13 +2278,13 @@ class DscConfigurationCreateOrUpdateParameters(msrest.serialization.Model): :vartype name: str :ivar location: Gets or sets the location of the resource. :vartype location: str - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] :ivar log_verbose: Gets or sets verbose log option. :vartype log_verbose: bool :ivar log_progress: Gets or sets progress log option. :vartype log_progress: bool - :ivar source: Required. Gets or sets the source. + :ivar source: Gets or sets the source. Required. :vartype source: ~azure.mgmt.automation.models.ContentSource :ivar parameters: Gets or sets the configuration parameters. :vartype parameters: dict[str, ~azure.mgmt.automation.models.DscConfigurationParameter] @@ -2306,18 +2293,18 @@ class DscConfigurationCreateOrUpdateParameters(msrest.serialization.Model): """ _validation = { - 'source': {'required': True}, + "source": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'log_verbose': {'key': 'properties.logVerbose', 'type': 'bool'}, - 'log_progress': {'key': 'properties.logProgress', 'type': 'bool'}, - 'source': {'key': 'properties.source', 'type': 'ContentSource'}, - 'parameters': {'key': 'properties.parameters', 'type': '{DscConfigurationParameter}'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "log_verbose": {"key": "properties.logVerbose", "type": "bool"}, + "log_progress": {"key": "properties.logProgress", "type": "bool"}, + "source": {"key": "properties.source", "type": "ContentSource"}, + "parameters": {"key": "properties.parameters", "type": "{DscConfigurationParameter}"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -2338,20 +2325,20 @@ def __init__( :paramtype name: str :keyword location: Gets or sets the location of the resource. :paramtype location: str - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] :keyword log_verbose: Gets or sets verbose log option. :paramtype log_verbose: bool :keyword log_progress: Gets or sets progress log option. :paramtype log_progress: bool - :keyword source: Required. Gets or sets the source. + :keyword source: Gets or sets the source. Required. :paramtype source: ~azure.mgmt.automation.models.ContentSource :keyword parameters: Gets or sets the configuration parameters. :paramtype parameters: dict[str, ~azure.mgmt.automation.models.DscConfigurationParameter] :keyword description: Gets or sets the description of the configuration. :paramtype description: str """ - super(DscConfigurationCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.location = location self.tags = tags @@ -2362,7 +2349,7 @@ def __init__( self.description = description -class DscConfigurationListResult(msrest.serialization.Model): +class DscConfigurationListResult(_serialization.Model): """The response model for the list configuration operation. :ivar value: Gets or sets a list of configurations. @@ -2374,9 +2361,9 @@ class DscConfigurationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DscConfiguration]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'total_count': {'key': 'totalCount', 'type': 'int'}, + "value": {"key": "value", "type": "[DscConfiguration]"}, + "next_link": {"key": "nextLink", "type": "str"}, + "total_count": {"key": "totalCount", "type": "int"}, } def __init__( @@ -2395,13 +2382,13 @@ def __init__( :keyword total_count: Gets the total number of configurations matching filter criteria. :paramtype total_count: int """ - super(DscConfigurationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link self.total_count = total_count -class DscConfigurationParameter(msrest.serialization.Model): +class DscConfigurationParameter(_serialization.Model): """Definition of the configuration parameter type. :ivar type: Gets or sets the type of the parameter. @@ -2416,10 +2403,10 @@ class DscConfigurationParameter(msrest.serialization.Model): """ _attribute_map = { - 'type': {'key': 'type', 'type': 'str'}, - 'is_mandatory': {'key': 'isMandatory', 'type': 'bool'}, - 'position': {'key': 'position', 'type': 'int'}, - 'default_value': {'key': 'defaultValue', 'type': 'str'}, + "type": {"key": "type", "type": "str"}, + "is_mandatory": {"key": "isMandatory", "type": "bool"}, + "position": {"key": "position", "type": "int"}, + "default_value": {"key": "defaultValue", "type": "str"}, } def __init__( @@ -2442,19 +2429,19 @@ def __init__( :keyword default_value: Gets or sets the default value of parameter. :paramtype default_value: str """ - super(DscConfigurationParameter, self).__init__(**kwargs) + super().__init__(**kwargs) self.type = type self.is_mandatory = is_mandatory self.position = position self.default_value = default_value -class DscConfigurationUpdateParameters(msrest.serialization.Model): +class DscConfigurationUpdateParameters(_serialization.Model): """The parameters supplied to the create or update configuration operation. :ivar name: Gets or sets name of the resource. :vartype name: str - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] :ivar log_verbose: Gets or sets verbose log option. :vartype log_verbose: bool @@ -2469,13 +2456,13 @@ class DscConfigurationUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'log_verbose': {'key': 'properties.logVerbose', 'type': 'bool'}, - 'log_progress': {'key': 'properties.logProgress', 'type': 'bool'}, - 'source': {'key': 'properties.source', 'type': 'ContentSource'}, - 'parameters': {'key': 'properties.parameters', 'type': '{DscConfigurationParameter}'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "log_verbose": {"key": "properties.logVerbose", "type": "bool"}, + "log_progress": {"key": "properties.logProgress", "type": "bool"}, + "source": {"key": "properties.source", "type": "ContentSource"}, + "parameters": {"key": "properties.parameters", "type": "{DscConfigurationParameter}"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -2493,7 +2480,7 @@ def __init__( """ :keyword name: Gets or sets name of the resource. :paramtype name: str - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] :keyword log_verbose: Gets or sets verbose log option. :paramtype log_verbose: bool @@ -2506,7 +2493,7 @@ def __init__( :keyword description: Gets or sets the description of the configuration. :paramtype description: str """ - super(DscConfigurationUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.tags = tags self.log_verbose = log_verbose @@ -2516,7 +2503,7 @@ def __init__( self.description = description -class DscMetaConfiguration(msrest.serialization.Model): +class DscMetaConfiguration(_serialization.Model): """Definition of the DSC Meta Configuration. :ivar configuration_mode_frequency_mins: Gets or sets the ConfigurationModeFrequencyMins value @@ -2540,13 +2527,13 @@ class DscMetaConfiguration(msrest.serialization.Model): """ _attribute_map = { - 'configuration_mode_frequency_mins': {'key': 'configurationModeFrequencyMins', 'type': 'int'}, - 'reboot_node_if_needed': {'key': 'rebootNodeIfNeeded', 'type': 'bool'}, - 'configuration_mode': {'key': 'configurationMode', 'type': 'str'}, - 'action_after_reboot': {'key': 'actionAfterReboot', 'type': 'str'}, - 'certificate_id': {'key': 'certificateId', 'type': 'str'}, - 'refresh_frequency_mins': {'key': 'refreshFrequencyMins', 'type': 'int'}, - 'allow_module_overwrite': {'key': 'allowModuleOverwrite', 'type': 'bool'}, + "configuration_mode_frequency_mins": {"key": "configurationModeFrequencyMins", "type": "int"}, + "reboot_node_if_needed": {"key": "rebootNodeIfNeeded", "type": "bool"}, + "configuration_mode": {"key": "configurationMode", "type": "str"}, + "action_after_reboot": {"key": "actionAfterReboot", "type": "str"}, + "certificate_id": {"key": "certificateId", "type": "str"}, + "refresh_frequency_mins": {"key": "refreshFrequencyMins", "type": "int"}, + "allow_module_overwrite": {"key": "allowModuleOverwrite", "type": "bool"}, } def __init__( @@ -2583,7 +2570,7 @@ def __init__( configuration. :paramtype allow_module_overwrite: bool """ - super(DscMetaConfiguration, self).__init__(**kwargs) + super().__init__(**kwargs) self.configuration_mode_frequency_mins = configuration_mode_frequency_mins self.reboot_node_if_needed = reboot_node_if_needed self.configuration_mode = configuration_mode @@ -2593,7 +2580,7 @@ def __init__( self.allow_module_overwrite = allow_module_overwrite -class DscNode(ProxyResource): +class DscNode(ProxyResource): # pylint: disable=too-many-instance-attributes """Definition of a DscNode. Variables are only populated by the server, and will be ignored when sending a request. @@ -2629,25 +2616,28 @@ class DscNode(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'last_seen': {'key': 'properties.lastSeen', 'type': 'iso-8601'}, - 'registration_time': {'key': 'properties.registrationTime', 'type': 'iso-8601'}, - 'ip': {'key': 'properties.ip', 'type': 'str'}, - 'account_id': {'key': 'properties.accountId', 'type': 'str'}, - 'status': {'key': 'properties.status', 'type': 'str'}, - 'node_id': {'key': 'properties.nodeId', 'type': 'str'}, - 'etag': {'key': 'properties.etag', 'type': 'str'}, - 'total_count': {'key': 'properties.totalCount', 'type': 'int'}, - 'extension_handler': {'key': 'properties.extensionHandler', 'type': '[DscNodeExtensionHandlerAssociationProperty]'}, - 'name_properties_node_configuration_name': {'key': 'properties.nodeConfiguration.name', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "last_seen": {"key": "properties.lastSeen", "type": "iso-8601"}, + "registration_time": {"key": "properties.registrationTime", "type": "iso-8601"}, + "ip": {"key": "properties.ip", "type": "str"}, + "account_id": {"key": "properties.accountId", "type": "str"}, + "status": {"key": "properties.status", "type": "str"}, + "node_id": {"key": "properties.nodeId", "type": "str"}, + "etag": {"key": "properties.etag", "type": "str"}, + "total_count": {"key": "properties.totalCount", "type": "int"}, + "extension_handler": { + "key": "properties.extensionHandler", + "type": "[DscNodeExtensionHandlerAssociationProperty]", + }, + "name_properties_node_configuration_name": {"key": "properties.nodeConfiguration.name", "type": "str"}, } def __init__( @@ -2689,7 +2679,7 @@ def __init__( configuration. :paramtype name_properties_node_configuration_name: str """ - super(DscNode, self).__init__(**kwargs) + super().__init__(**kwargs) self.last_seen = last_seen self.registration_time = registration_time self.ip = ip @@ -2722,28 +2712,28 @@ class DscNodeConfiguration(ProxyResource): :ivar source: Source of node configuration. :vartype source: str :ivar node_count: Number of nodes with this node configuration assigned. - :vartype node_count: long + :vartype node_count: int :ivar increment_node_configuration_build: If a new build version of NodeConfiguration is required. :vartype increment_node_configuration_build: bool """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'configuration': {'key': 'properties.configuration', 'type': 'DscConfigurationAssociationProperty'}, - 'source': {'key': 'properties.source', 'type': 'str'}, - 'node_count': {'key': 'properties.nodeCount', 'type': 'long'}, - 'increment_node_configuration_build': {'key': 'properties.incrementNodeConfigurationBuild', 'type': 'bool'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "configuration": {"key": "properties.configuration", "type": "DscConfigurationAssociationProperty"}, + "source": {"key": "properties.source", "type": "str"}, + "node_count": {"key": "properties.nodeCount", "type": "int"}, + "increment_node_configuration_build": {"key": "properties.incrementNodeConfigurationBuild", "type": "bool"}, } def __init__( @@ -2767,12 +2757,12 @@ def __init__( :keyword source: Source of node configuration. :paramtype source: str :keyword node_count: Number of nodes with this node configuration assigned. - :paramtype node_count: long + :paramtype node_count: int :keyword increment_node_configuration_build: If a new build version of NodeConfiguration is required. :paramtype increment_node_configuration_build: bool """ - super(DscNodeConfiguration, self).__init__(**kwargs) + super().__init__(**kwargs) self.last_modified_time = last_modified_time self.creation_time = creation_time self.configuration = configuration @@ -2781,12 +2771,12 @@ def __init__( self.increment_node_configuration_build = increment_node_configuration_build -class DscNodeConfigurationCreateOrUpdateParameters(msrest.serialization.Model): +class DscNodeConfigurationCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update node configuration operation. :ivar name: Name of the node configuration. :vartype name: str - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] :ivar source: Gets or sets the source. :vartype source: ~azure.mgmt.automation.models.ContentSource @@ -2798,11 +2788,11 @@ class DscNodeConfigurationCreateOrUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'source': {'key': 'properties.source', 'type': 'ContentSource'}, - 'configuration': {'key': 'properties.configuration', 'type': 'DscConfigurationAssociationProperty'}, - 'increment_node_configuration_build': {'key': 'properties.incrementNodeConfigurationBuild', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "source": {"key": "properties.source", "type": "ContentSource"}, + "configuration": {"key": "properties.configuration", "type": "DscConfigurationAssociationProperty"}, + "increment_node_configuration_build": {"key": "properties.incrementNodeConfigurationBuild", "type": "bool"}, } def __init__( @@ -2818,7 +2808,7 @@ def __init__( """ :keyword name: Name of the node configuration. :paramtype name: str - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] :keyword source: Gets or sets the source. :paramtype source: ~azure.mgmt.automation.models.ContentSource @@ -2828,7 +2818,7 @@ def __init__( required. :paramtype increment_node_configuration_build: bool """ - super(DscNodeConfigurationCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.tags = tags self.source = source @@ -2836,7 +2826,7 @@ def __init__( self.increment_node_configuration_build = increment_node_configuration_build -class DscNodeConfigurationListResult(msrest.serialization.Model): +class DscNodeConfigurationListResult(_serialization.Model): """The response model for the list job operation. :ivar value: Gets or sets a list of Dsc node configurations. @@ -2848,9 +2838,9 @@ class DscNodeConfigurationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DscNodeConfiguration]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'total_count': {'key': 'totalCount', 'type': 'int'}, + "value": {"key": "value", "type": "[DscNodeConfiguration]"}, + "next_link": {"key": "nextLink", "type": "str"}, + "total_count": {"key": "totalCount", "type": "int"}, } def __init__( @@ -2869,13 +2859,13 @@ def __init__( :keyword total_count: Gets or sets the total rows in query. :paramtype total_count: int """ - super(DscNodeConfigurationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link self.total_count = total_count -class DscNodeExtensionHandlerAssociationProperty(msrest.serialization.Model): +class DscNodeExtensionHandlerAssociationProperty(_serialization.Model): """The dsc extensionHandler property associated with the node. :ivar name: Gets or sets the name of the extension handler. @@ -2885,29 +2875,23 @@ class DscNodeExtensionHandlerAssociationProperty(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'version': {'key': 'version', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "version": {"key": "version", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - version: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, version: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the extension handler. :paramtype name: str :keyword version: Gets or sets the version of the extension handler. :paramtype version: str """ - super(DscNodeExtensionHandlerAssociationProperty, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.version = version -class DscNodeListResult(msrest.serialization.Model): +class DscNodeListResult(_serialization.Model): """The response model for the list dsc nodes operation. :ivar value: Gets or sets a list of dsc nodes. @@ -2919,9 +2903,9 @@ class DscNodeListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DscNode]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, - 'total_count': {'key': 'totalCount', 'type': 'int'}, + "value": {"key": "value", "type": "[DscNode]"}, + "next_link": {"key": "nextLink", "type": "str"}, + "total_count": {"key": "totalCount", "type": "int"}, } def __init__( @@ -2940,13 +2924,13 @@ def __init__( :keyword total_count: Gets the total number of nodes matching filter criteria. :paramtype total_count: int """ - super(DscNodeListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link self.total_count = total_count -class DscNodeReport(msrest.serialization.Model): +class DscNodeReport(_serialization.Model): # pylint: disable=too-many-instance-attributes """Definition of the dsc node report type. :ivar end_time: Gets or sets the end time of the node report. @@ -2991,25 +2975,25 @@ class DscNodeReport(msrest.serialization.Model): """ _attribute_map = { - 'end_time': {'key': 'endTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'lastModifiedTime', 'type': 'iso-8601'}, - 'start_time': {'key': 'startTime', 'type': 'iso-8601'}, - 'type': {'key': 'type', 'type': 'str'}, - 'report_id': {'key': 'reportId', 'type': 'str'}, - 'status': {'key': 'status', 'type': 'str'}, - 'refresh_mode': {'key': 'refreshMode', 'type': 'str'}, - 'reboot_requested': {'key': 'rebootRequested', 'type': 'str'}, - 'report_format_version': {'key': 'reportFormatVersion', 'type': 'str'}, - 'configuration_version': {'key': 'configurationVersion', 'type': 'str'}, - 'id': {'key': 'id', 'type': 'str'}, - 'errors': {'key': 'errors', 'type': '[DscReportError]'}, - 'resources': {'key': 'resources', 'type': '[DscReportResource]'}, - 'meta_configuration': {'key': 'metaConfiguration', 'type': 'DscMetaConfiguration'}, - 'host_name': {'key': 'hostName', 'type': 'str'}, - 'i_pv4_addresses': {'key': 'iPV4Addresses', 'type': '[str]'}, - 'i_pv6_addresses': {'key': 'iPV6Addresses', 'type': '[str]'}, - 'number_of_resources': {'key': 'numberOfResources', 'type': 'int'}, - 'raw_errors': {'key': 'rawErrors', 'type': 'str'}, + "end_time": {"key": "endTime", "type": "iso-8601"}, + "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"}, + "start_time": {"key": "startTime", "type": "iso-8601"}, + "type": {"key": "type", "type": "str"}, + "report_id": {"key": "reportId", "type": "str"}, + "status": {"key": "status", "type": "str"}, + "refresh_mode": {"key": "refreshMode", "type": "str"}, + "reboot_requested": {"key": "rebootRequested", "type": "str"}, + "report_format_version": {"key": "reportFormatVersion", "type": "str"}, + "configuration_version": {"key": "configurationVersion", "type": "str"}, + "id": {"key": "id", "type": "str"}, + "errors": {"key": "errors", "type": "[DscReportError]"}, + "resources": {"key": "resources", "type": "[DscReportResource]"}, + "meta_configuration": {"key": "metaConfiguration", "type": "DscMetaConfiguration"}, + "host_name": {"key": "hostName", "type": "str"}, + "i_pv4_addresses": {"key": "iPV4Addresses", "type": "[str]"}, + "i_pv6_addresses": {"key": "iPV6Addresses", "type": "[str]"}, + "number_of_resources": {"key": "numberOfResources", "type": "int"}, + "raw_errors": {"key": "rawErrors", "type": "str"}, } def __init__( @@ -3025,7 +3009,7 @@ def __init__( reboot_requested: Optional[str] = None, report_format_version: Optional[str] = None, configuration_version: Optional[str] = None, - id: Optional[str] = None, + id: Optional[str] = None, # pylint: disable=redefined-builtin errors: Optional[List["_models.DscReportError"]] = None, resources: Optional[List["_models.DscReportResource"]] = None, meta_configuration: Optional["_models.DscMetaConfiguration"] = None, @@ -3077,7 +3061,7 @@ def __init__( :keyword raw_errors: Gets or sets the unparsed errors for the node report. :paramtype raw_errors: str """ - super(DscNodeReport, self).__init__(**kwargs) + super().__init__(**kwargs) self.end_time = end_time self.last_modified_time = last_modified_time self.start_time = start_time @@ -3099,7 +3083,7 @@ def __init__( self.raw_errors = raw_errors -class DscNodeReportListResult(msrest.serialization.Model): +class DscNodeReportListResult(_serialization.Model): """The response model for the list dsc nodes operation. :ivar value: Gets or sets a list of dsc node reports. @@ -3109,16 +3093,12 @@ class DscNodeReportListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[DscNodeReport]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[DscNodeReport]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.DscNodeReport"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.DscNodeReport"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets a list of dsc node reports. @@ -3126,12 +3106,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(DscNodeReportListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class DscNodeUpdateParameters(msrest.serialization.Model): +class DscNodeUpdateParameters(_serialization.Model): """The parameters supplied to the update dsc node operation. :ivar node_id: Gets or sets the id of the dsc node. @@ -3141,8 +3121,8 @@ class DscNodeUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'node_id': {'key': 'nodeId', 'type': 'str'}, - 'properties': {'key': 'properties', 'type': 'DscNodeUpdateParametersProperties'}, + "node_id": {"key": "nodeId", "type": "str"}, + "properties": {"key": "properties", "type": "DscNodeUpdateParametersProperties"}, } def __init__( @@ -3158,12 +3138,12 @@ def __init__( :keyword properties: :paramtype properties: ~azure.mgmt.automation.models.DscNodeUpdateParametersProperties """ - super(DscNodeUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.node_id = node_id self.properties = properties -class DscNodeUpdateParametersProperties(msrest.serialization.Model): +class DscNodeUpdateParametersProperties(_serialization.Model): """DscNodeUpdateParametersProperties. :ivar name: Gets or sets the name of the dsc node configuration. @@ -3171,24 +3151,19 @@ class DscNodeUpdateParametersProperties(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'nodeConfiguration.name', 'type': 'str'}, + "name": {"key": "nodeConfiguration.name", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the dsc node configuration. :paramtype name: str """ - super(DscNodeUpdateParametersProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class DscReportError(msrest.serialization.Model): +class DscReportError(_serialization.Model): """Definition of the dsc node report error type. :ivar error_source: Gets or sets the source of the error. @@ -3206,12 +3181,12 @@ class DscReportError(msrest.serialization.Model): """ _attribute_map = { - 'error_source': {'key': 'errorSource', 'type': 'str'}, - 'resource_id': {'key': 'resourceId', 'type': 'str'}, - 'error_code': {'key': 'errorCode', 'type': 'str'}, - 'error_message': {'key': 'errorMessage', 'type': 'str'}, - 'locale': {'key': 'locale', 'type': 'str'}, - 'error_details': {'key': 'errorDetails', 'type': 'str'}, + "error_source": {"key": "errorSource", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + "error_code": {"key": "errorCode", "type": "str"}, + "error_message": {"key": "errorMessage", "type": "str"}, + "locale": {"key": "locale", "type": "str"}, + "error_details": {"key": "errorDetails", "type": "str"}, } def __init__( @@ -3239,7 +3214,7 @@ def __init__( :keyword error_details: Gets or sets the error details. :paramtype error_details: str """ - super(DscReportError, self).__init__(**kwargs) + super().__init__(**kwargs) self.error_source = error_source self.resource_id = resource_id self.error_code = error_code @@ -3248,7 +3223,7 @@ def __init__( self.error_details = error_details -class DscReportResource(msrest.serialization.Model): +class DscReportResource(_serialization.Model): """Definition of the DSC Report Resource. :ivar resource_id: Gets or sets the ID of the resource. @@ -3275,16 +3250,16 @@ class DscReportResource(msrest.serialization.Model): """ _attribute_map = { - 'resource_id': {'key': 'resourceId', 'type': 'str'}, - 'source_info': {'key': 'sourceInfo', 'type': 'str'}, - 'depends_on': {'key': 'dependsOn', 'type': '[DscReportResourceNavigation]'}, - 'module_name': {'key': 'moduleName', 'type': 'str'}, - 'module_version': {'key': 'moduleVersion', 'type': 'str'}, - 'resource_name': {'key': 'resourceName', 'type': 'str'}, - 'error': {'key': 'error', 'type': 'str'}, - 'status': {'key': 'status', 'type': 'str'}, - 'duration_in_seconds': {'key': 'durationInSeconds', 'type': 'float'}, - 'start_date': {'key': 'startDate', 'type': 'iso-8601'}, + "resource_id": {"key": "resourceId", "type": "str"}, + "source_info": {"key": "sourceInfo", "type": "str"}, + "depends_on": {"key": "dependsOn", "type": "[DscReportResourceNavigation]"}, + "module_name": {"key": "moduleName", "type": "str"}, + "module_version": {"key": "moduleVersion", "type": "str"}, + "resource_name": {"key": "resourceName", "type": "str"}, + "error": {"key": "error", "type": "str"}, + "status": {"key": "status", "type": "str"}, + "duration_in_seconds": {"key": "durationInSeconds", "type": "float"}, + "start_date": {"key": "startDate", "type": "iso-8601"}, } def __init__( @@ -3325,7 +3300,7 @@ def __init__( :keyword start_date: Gets or sets the start date of the resource. :paramtype start_date: ~datetime.datetime """ - super(DscReportResource, self).__init__(**kwargs) + super().__init__(**kwargs) self.resource_id = resource_id self.source_info = source_info self.depends_on = depends_on @@ -3338,7 +3313,7 @@ def __init__( self.start_date = start_date -class DscReportResourceNavigation(msrest.serialization.Model): +class DscReportResourceNavigation(_serialization.Model): """Navigation for DSC Report Resource. :ivar resource_id: Gets or sets the ID of the resource to navigate to. @@ -3346,29 +3321,24 @@ class DscReportResourceNavigation(msrest.serialization.Model): """ _attribute_map = { - 'resource_id': {'key': 'resourceId', 'type': 'str'}, + "resource_id": {"key": "resourceId", "type": "str"}, } - def __init__( - self, - *, - resource_id: Optional[str] = None, - **kwargs - ): + def __init__(self, *, resource_id: Optional[str] = None, **kwargs): """ :keyword resource_id: Gets or sets the ID of the resource to navigate to. :paramtype resource_id: str """ - super(DscReportResourceNavigation, self).__init__(**kwargs) + super().__init__(**kwargs) self.resource_id = resource_id -class EncryptionProperties(msrest.serialization.Model): +class EncryptionProperties(_serialization.Model): """The encryption settings for automation account. :ivar key_vault_properties: Key vault properties. :vartype key_vault_properties: ~azure.mgmt.automation.models.KeyVaultProperties - :ivar key_source: Encryption Key Source. Known values are: "Microsoft.Automation", + :ivar key_source: Encryption Key Source. Known values are: "Microsoft.Automation" and "Microsoft.Keyvault". :vartype key_source: str or ~azure.mgmt.automation.models.EncryptionKeySourceType :ivar identity: User identity used for CMK. @@ -3376,9 +3346,9 @@ class EncryptionProperties(msrest.serialization.Model): """ _attribute_map = { - 'key_vault_properties': {'key': 'keyVaultProperties', 'type': 'KeyVaultProperties'}, - 'key_source': {'key': 'keySource', 'type': 'str'}, - 'identity': {'key': 'identity', 'type': 'EncryptionPropertiesIdentity'}, + "key_vault_properties": {"key": "keyVaultProperties", "type": "KeyVaultProperties"}, + "key_source": {"key": "keySource", "type": "str"}, + "identity": {"key": "identity", "type": "EncryptionPropertiesIdentity"}, } def __init__( @@ -3392,48 +3362,43 @@ def __init__( """ :keyword key_vault_properties: Key vault properties. :paramtype key_vault_properties: ~azure.mgmt.automation.models.KeyVaultProperties - :keyword key_source: Encryption Key Source. Known values are: "Microsoft.Automation", + :keyword key_source: Encryption Key Source. Known values are: "Microsoft.Automation" and "Microsoft.Keyvault". :paramtype key_source: str or ~azure.mgmt.automation.models.EncryptionKeySourceType :keyword identity: User identity used for CMK. :paramtype identity: ~azure.mgmt.automation.models.EncryptionPropertiesIdentity """ - super(EncryptionProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.key_vault_properties = key_vault_properties self.key_source = key_source self.identity = identity -class EncryptionPropertiesIdentity(msrest.serialization.Model): +class EncryptionPropertiesIdentity(_serialization.Model): """User identity used for CMK. :ivar user_assigned_identity: The user identity used for CMK. It will be an ARM resource id in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'. - :vartype user_assigned_identity: any + :vartype user_assigned_identity: JSON """ _attribute_map = { - 'user_assigned_identity': {'key': 'userAssignedIdentity', 'type': 'object'}, + "user_assigned_identity": {"key": "userAssignedIdentity", "type": "object"}, } - def __init__( - self, - *, - user_assigned_identity: Optional[Any] = None, - **kwargs - ): + def __init__(self, *, user_assigned_identity: Optional[JSON] = None, **kwargs): """ :keyword user_assigned_identity: The user identity used for CMK. It will be an ARM resource id in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'. - :paramtype user_assigned_identity: any + :paramtype user_assigned_identity: JSON """ - super(EncryptionPropertiesIdentity, self).__init__(**kwargs) + super().__init__(**kwargs) self.user_assigned_identity = user_assigned_identity -class ErrorResponse(msrest.serialization.Model): +class ErrorResponse(_serialization.Model): """Error response of an operation failure. :ivar code: Error code. @@ -3443,29 +3408,23 @@ class ErrorResponse(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Error code. :paramtype code: str :keyword message: Error message indicating why the operation failed. :paramtype message: str """ - super(ErrorResponse, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class FieldDefinition(msrest.serialization.Model): +class FieldDefinition(_serialization.Model): """Definition of the connection fields. All required parameters must be populated in order to send to Azure. @@ -3474,43 +3433,36 @@ class FieldDefinition(msrest.serialization.Model): :vartype is_encrypted: bool :ivar is_optional: Gets or sets the isOptional flag of the connection field definition. :vartype is_optional: bool - :ivar type: Required. Gets or sets the type of the connection field definition. + :ivar type: Gets or sets the type of the connection field definition. Required. :vartype type: str """ _validation = { - 'type': {'required': True}, + "type": {"required": True}, } _attribute_map = { - 'is_encrypted': {'key': 'isEncrypted', 'type': 'bool'}, - 'is_optional': {'key': 'isOptional', 'type': 'bool'}, - 'type': {'key': 'type', 'type': 'str'}, + "is_encrypted": {"key": "isEncrypted", "type": "bool"}, + "is_optional": {"key": "isOptional", "type": "bool"}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - *, - type: str, - is_encrypted: Optional[bool] = None, - is_optional: Optional[bool] = None, - **kwargs - ): + def __init__(self, *, type: str, is_encrypted: Optional[bool] = None, is_optional: Optional[bool] = None, **kwargs): """ :keyword is_encrypted: Gets or sets the isEncrypted flag of the connection field definition. :paramtype is_encrypted: bool :keyword is_optional: Gets or sets the isOptional flag of the connection field definition. :paramtype is_optional: bool - :keyword type: Required. Gets or sets the type of the connection field definition. + :keyword type: Gets or sets the type of the connection field definition. Required. :paramtype type: str """ - super(FieldDefinition, self).__init__(**kwargs) + super().__init__(**kwargs) self.is_encrypted = is_encrypted self.is_optional = is_optional self.type = type -class GraphicalRunbookContent(msrest.serialization.Model): +class GraphicalRunbookContent(_serialization.Model): """Graphical Runbook Content. :ivar raw_content: Raw graphical Runbook content. @@ -3520,8 +3472,8 @@ class GraphicalRunbookContent(msrest.serialization.Model): """ _attribute_map = { - 'raw_content': {'key': 'rawContent', 'type': 'RawGraphicalRunbookContent'}, - 'graph_runbook_json': {'key': 'graphRunbookJson', 'type': 'str'}, + "raw_content": {"key": "rawContent", "type": "RawGraphicalRunbookContent"}, + "graph_runbook_json": {"key": "graphRunbookJson", "type": "str"}, } def __init__( @@ -3537,7 +3489,7 @@ def __init__( :keyword graph_runbook_json: Graphical Runbook content as JSON. :paramtype graph_runbook_json: str """ - super(GraphicalRunbookContent, self).__init__(**kwargs) + super().__init__(**kwargs) self.raw_content = raw_content self.graph_runbook_json = graph_runbook_json @@ -3563,30 +3515,30 @@ class HybridRunbookWorker(Resource): :vartype last_seen_date_time: ~datetime.datetime :ivar vm_resource_id: Azure Resource Manager Id for a virtual machine. :vartype vm_resource_id: str - :ivar worker_type: Type of the HybridWorker. Known values are: "HybridV1", "HybridV2". + :ivar worker_type: Type of the HybridWorker. Known values are: "HybridV1" and "HybridV2". :vartype worker_type: str or ~azure.mgmt.automation.models.WorkerType :ivar worker_name: Name of the HybridWorker. :vartype worker_name: str """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'system_data': {'key': 'systemData', 'type': 'SystemData'}, - 'ip': {'key': 'properties.ip', 'type': 'str'}, - 'registered_date_time': {'key': 'properties.registeredDateTime', 'type': 'iso-8601'}, - 'last_seen_date_time': {'key': 'properties.lastSeenDateTime', 'type': 'iso-8601'}, - 'vm_resource_id': {'key': 'properties.vmResourceId', 'type': 'str'}, - 'worker_type': {'key': 'properties.workerType', 'type': 'str'}, - 'worker_name': {'key': 'properties.workerName', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "ip": {"key": "properties.ip", "type": "str"}, + "registered_date_time": {"key": "properties.registeredDateTime", "type": "iso-8601"}, + "last_seen_date_time": {"key": "properties.lastSeenDateTime", "type": "iso-8601"}, + "vm_resource_id": {"key": "properties.vmResourceId", "type": "str"}, + "worker_type": {"key": "properties.workerType", "type": "str"}, + "worker_name": {"key": "properties.workerName", "type": "str"}, } def __init__( @@ -3609,12 +3561,12 @@ def __init__( :paramtype last_seen_date_time: ~datetime.datetime :keyword vm_resource_id: Azure Resource Manager Id for a virtual machine. :paramtype vm_resource_id: str - :keyword worker_type: Type of the HybridWorker. Known values are: "HybridV1", "HybridV2". + :keyword worker_type: Type of the HybridWorker. Known values are: "HybridV1" and "HybridV2". :paramtype worker_type: str or ~azure.mgmt.automation.models.WorkerType :keyword worker_name: Name of the HybridWorker. :paramtype worker_name: str """ - super(HybridRunbookWorker, self).__init__(**kwargs) + super().__init__(**kwargs) self.system_data = None self.ip = ip self.registered_date_time = registered_date_time @@ -3624,7 +3576,7 @@ def __init__( self.worker_name = worker_name -class HybridRunbookWorkerCreateParameters(msrest.serialization.Model): +class HybridRunbookWorkerCreateParameters(_serialization.Model): """The parameters supplied to the create hybrid runbook worker operation. :ivar name: Gets or sets the name of the resource. @@ -3634,123 +3586,109 @@ class HybridRunbookWorkerCreateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'vm_resource_id': {'key': 'properties.vmResourceId', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "vm_resource_id": {"key": "properties.vmResourceId", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - vm_resource_id: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, vm_resource_id: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the resource. :paramtype name: str :keyword vm_resource_id: Azure Resource Manager Id for a virtual machine. :paramtype vm_resource_id: str """ - super(HybridRunbookWorkerCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.vm_resource_id = vm_resource_id -class HybridRunbookWorkerGroup(msrest.serialization.Model): +class HybridRunbookWorkerGroup(Resource): """Definition of hybrid runbook worker group. Variables are only populated by the server, and will be ignored when sending a request. - :ivar id: Gets or sets the id of the resource. + :ivar id: Fully qualified resource Id for the resource. :vartype id: str - :ivar name: Gets or sets the name of the group. + :ivar name: The name of the resource. :vartype name: str :ivar type: The type of the resource. :vartype type: str - :ivar hybrid_runbook_workers: Gets or sets the list of hybrid runbook workers. - :vartype hybrid_runbook_workers: list[~azure.mgmt.automation.models.HybridRunbookWorkerLegacy] - :ivar credential: Sets the credential of a worker group. - :vartype credential: ~azure.mgmt.automation.models.RunAsCredentialAssociationProperty - :ivar group_type: Type of the HybridWorkerGroup. Known values are: "User", "System". - :vartype group_type: str or ~azure.mgmt.automation.models.GroupTypeEnum :ivar system_data: Resource system metadata. :vartype system_data: ~azure.mgmt.automation.models.SystemData + :ivar group_type: Type of the HybridWorkerGroup. Known values are: "User" and "System". + :vartype group_type: str or ~azure.mgmt.automation.models.GroupTypeEnum + :ivar credential: Sets the credential of a worker group. + :vartype credential: ~azure.mgmt.automation.models.RunAsCredentialAssociationProperty """ _validation = { - 'type': {'readonly': True}, - 'system_data': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "system_data": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'hybrid_runbook_workers': {'key': 'hybridRunbookWorkers', 'type': '[HybridRunbookWorkerLegacy]'}, - 'credential': {'key': 'credential', 'type': 'RunAsCredentialAssociationProperty'}, - 'group_type': {'key': 'groupType', 'type': 'str'}, - 'system_data': {'key': 'systemData', 'type': 'SystemData'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "system_data": {"key": "systemData", "type": "SystemData"}, + "group_type": {"key": "properties.groupType", "type": "str"}, + "credential": {"key": "properties.credential", "type": "RunAsCredentialAssociationProperty"}, } def __init__( self, *, - id: Optional[str] = None, - name: Optional[str] = None, - hybrid_runbook_workers: Optional[List["_models.HybridRunbookWorkerLegacy"]] = None, - credential: Optional["_models.RunAsCredentialAssociationProperty"] = None, group_type: Optional[Union[str, "_models.GroupTypeEnum"]] = None, + credential: Optional["_models.RunAsCredentialAssociationProperty"] = None, **kwargs ): """ - :keyword id: Gets or sets the id of the resource. - :paramtype id: str - :keyword name: Gets or sets the name of the group. - :paramtype name: str - :keyword hybrid_runbook_workers: Gets or sets the list of hybrid runbook workers. - :paramtype hybrid_runbook_workers: - list[~azure.mgmt.automation.models.HybridRunbookWorkerLegacy] + :keyword group_type: Type of the HybridWorkerGroup. Known values are: "User" and "System". + :paramtype group_type: str or ~azure.mgmt.automation.models.GroupTypeEnum :keyword credential: Sets the credential of a worker group. :paramtype credential: ~azure.mgmt.automation.models.RunAsCredentialAssociationProperty - :keyword group_type: Type of the HybridWorkerGroup. Known values are: "User", "System". - :paramtype group_type: str or ~azure.mgmt.automation.models.GroupTypeEnum """ - super(HybridRunbookWorkerGroup, self).__init__(**kwargs) - self.id = id - self.name = name - self.type = None - self.hybrid_runbook_workers = hybrid_runbook_workers - self.credential = credential - self.group_type = group_type + super().__init__(**kwargs) self.system_data = None + self.group_type = group_type + self.credential = credential -class HybridRunbookWorkerGroupCreateOrUpdateParameters(msrest.serialization.Model): - """The parameters supplied to the create or update hybrid runbook worker group operation. +class HybridRunbookWorkerGroupCreateOrUpdateParameters(_serialization.Model): + """The parameters supplied to the create hybrid runbook worker group operation. + :ivar name: Gets or sets the name of the resource. + :vartype name: str :ivar credential: Sets the credential of a worker group. :vartype credential: ~azure.mgmt.automation.models.RunAsCredentialAssociationProperty """ _attribute_map = { - 'credential': {'key': 'credential', 'type': 'RunAsCredentialAssociationProperty'}, + "name": {"key": "name", "type": "str"}, + "credential": {"key": "properties.credential", "type": "RunAsCredentialAssociationProperty"}, } def __init__( self, *, + name: Optional[str] = None, credential: Optional["_models.RunAsCredentialAssociationProperty"] = None, **kwargs ): """ + :keyword name: Gets or sets the name of the resource. + :paramtype name: str :keyword credential: Sets the credential of a worker group. :paramtype credential: ~azure.mgmt.automation.models.RunAsCredentialAssociationProperty """ - super(HybridRunbookWorkerGroupCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) + self.name = name self.credential = credential -class HybridRunbookWorkerGroupsListResult(msrest.serialization.Model): +class HybridRunbookWorkerGroupsListResult(_serialization.Model): """The response model for the list hybrid runbook worker groups. :ivar value: Gets or sets a list of hybrid runbook worker groups. @@ -3760,8 +3698,8 @@ class HybridRunbookWorkerGroupsListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[HybridRunbookWorkerGroup]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[HybridRunbookWorkerGroup]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -3777,83 +3715,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(HybridRunbookWorkerGroupsListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class HybridRunbookWorkerGroupUpdateParameters(msrest.serialization.Model): - """Parameters supplied to the update operation. - - :ivar credential: Sets the credential of a worker group. - :vartype credential: ~azure.mgmt.automation.models.RunAsCredentialAssociationProperty - """ - - _attribute_map = { - 'credential': {'key': 'credential', 'type': 'RunAsCredentialAssociationProperty'}, - } - - def __init__( - self, - *, - credential: Optional["_models.RunAsCredentialAssociationProperty"] = None, - **kwargs - ): - """ - :keyword credential: Sets the credential of a worker group. - :paramtype credential: ~azure.mgmt.automation.models.RunAsCredentialAssociationProperty - """ - super(HybridRunbookWorkerGroupUpdateParameters, self).__init__(**kwargs) - self.credential = credential - - -class HybridRunbookWorkerLegacy(msrest.serialization.Model): - """Definition of hybrid runbook worker Legacy. - - :ivar name: Gets or sets the worker machine name. - :vartype name: str - :ivar ip: Gets or sets the assigned machine IP address. - :vartype ip: str - :ivar registration_time: Gets or sets the registration time of the worker machine. - :vartype registration_time: ~datetime.datetime - :ivar last_seen_date_time: Last Heartbeat from the Worker. - :vartype last_seen_date_time: ~datetime.datetime - """ - - _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'ip': {'key': 'ip', 'type': 'str'}, - 'registration_time': {'key': 'registrationTime', 'type': 'iso-8601'}, - 'last_seen_date_time': {'key': 'lastSeenDateTime', 'type': 'iso-8601'}, - } - - def __init__( - self, - *, - name: Optional[str] = None, - ip: Optional[str] = None, - registration_time: Optional[datetime.datetime] = None, - last_seen_date_time: Optional[datetime.datetime] = None, - **kwargs - ): - """ - :keyword name: Gets or sets the worker machine name. - :paramtype name: str - :keyword ip: Gets or sets the assigned machine IP address. - :paramtype ip: str - :keyword registration_time: Gets or sets the registration time of the worker machine. - :paramtype registration_time: ~datetime.datetime - :keyword last_seen_date_time: Last Heartbeat from the Worker. - :paramtype last_seen_date_time: ~datetime.datetime - """ - super(HybridRunbookWorkerLegacy, self).__init__(**kwargs) - self.name = name - self.ip = ip - self.registration_time = registration_time - self.last_seen_date_time = last_seen_date_time - - -class HybridRunbookWorkerMoveParameters(msrest.serialization.Model): +class HybridRunbookWorkerMoveParameters(_serialization.Model): """Parameters supplied to move hybrid worker operation. :ivar hybrid_runbook_worker_group_name: Gets or sets the target hybrid runbook worker group. @@ -3861,24 +3728,19 @@ class HybridRunbookWorkerMoveParameters(msrest.serialization.Model): """ _attribute_map = { - 'hybrid_runbook_worker_group_name': {'key': 'hybridRunbookWorkerGroupName', 'type': 'str'}, + "hybrid_runbook_worker_group_name": {"key": "hybridRunbookWorkerGroupName", "type": "str"}, } - def __init__( - self, - *, - hybrid_runbook_worker_group_name: Optional[str] = None, - **kwargs - ): + def __init__(self, *, hybrid_runbook_worker_group_name: Optional[str] = None, **kwargs): """ :keyword hybrid_runbook_worker_group_name: Gets or sets the target hybrid runbook worker group. :paramtype hybrid_runbook_worker_group_name: str """ - super(HybridRunbookWorkerMoveParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.hybrid_runbook_worker_group_name = hybrid_runbook_worker_group_name -class HybridRunbookWorkersListResult(msrest.serialization.Model): +class HybridRunbookWorkersListResult(_serialization.Model): """The response model for the list hybrid runbook workers. :ivar value: Gets or sets a list of hybrid runbook workers. @@ -3888,16 +3750,12 @@ class HybridRunbookWorkersListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[HybridRunbookWorker]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[HybridRunbookWorker]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.HybridRunbookWorker"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.HybridRunbookWorker"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets a list of hybrid runbook workers. @@ -3905,12 +3763,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(HybridRunbookWorkersListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Identity(msrest.serialization.Model): +class Identity(_serialization.Model): """Identity for the resource. Variables are only populated by the server, and will be ignored when sending a request. @@ -3920,52 +3778,52 @@ class Identity(msrest.serialization.Model): :ivar tenant_id: The tenant ID of resource. :vartype tenant_id: str :ivar type: The identity type. Known values are: "SystemAssigned", "UserAssigned", - "SystemAssigned, UserAssigned", "None". + "SystemAssigned, UserAssigned", and "None". :vartype type: str or ~azure.mgmt.automation.models.ResourceIdentityType :ivar user_assigned_identities: The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'. :vartype user_assigned_identities: dict[str, - ~azure.mgmt.automation.models.ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties] + ~azure.mgmt.automation.models.UserAssignedIdentitiesProperties] """ _validation = { - 'principal_id': {'readonly': True}, - 'tenant_id': {'readonly': True}, + "principal_id": {"readonly": True}, + "tenant_id": {"readonly": True}, } _attribute_map = { - 'principal_id': {'key': 'principalId', 'type': 'str'}, - 'tenant_id': {'key': 'tenantId', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'user_assigned_identities': {'key': 'userAssignedIdentities', 'type': '{ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties}'}, + "principal_id": {"key": "principalId", "type": "str"}, + "tenant_id": {"key": "tenantId", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "user_assigned_identities": {"key": "userAssignedIdentities", "type": "{UserAssignedIdentitiesProperties}"}, } def __init__( self, *, type: Optional[Union[str, "_models.ResourceIdentityType"]] = None, - user_assigned_identities: Optional[Dict[str, "_models.ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties"]] = None, + user_assigned_identities: Optional[Dict[str, "_models.UserAssignedIdentitiesProperties"]] = None, **kwargs ): """ :keyword type: The identity type. Known values are: "SystemAssigned", "UserAssigned", - "SystemAssigned, UserAssigned", "None". + "SystemAssigned, UserAssigned", and "None". :paramtype type: str or ~azure.mgmt.automation.models.ResourceIdentityType :keyword user_assigned_identities: The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'. :paramtype user_assigned_identities: dict[str, - ~azure.mgmt.automation.models.ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties] + ~azure.mgmt.automation.models.UserAssignedIdentitiesProperties] """ - super(Identity, self).__init__(**kwargs) + super().__init__(**kwargs) self.principal_id = None self.tenant_id = None self.type = type self.user_assigned_identities = user_assigned_identities -class Job(ProxyResource): +class Job(ProxyResource): # pylint: disable=too-many-instance-attributes """Definition of the job. Variables are only populated by the server, and will be ignored when sending a request. @@ -3989,7 +3847,7 @@ class Job(ProxyResource): :vartype creation_time: ~datetime.datetime :ivar status: Gets or sets the status of the job. Known values are: "New", "Activating", "Running", "Completed", "Failed", "Stopped", "Blocked", "Suspended", "Disconnected", - "Suspending", "Stopping", "Resuming", "Removing". + "Suspending", "Stopping", "Resuming", and "Removing". :vartype status: str or ~azure.mgmt.automation.models.JobStatus :ivar status_details: Gets or sets the status details of the job. :vartype status_details: str @@ -4006,34 +3864,34 @@ class Job(ProxyResource): :ivar parameters: Gets or sets the parameters of the job. :vartype parameters: dict[str, str] :ivar provisioning_state: The current provisioning state of the job. Known values are: - "Failed", "Succeeded", "Suspended", "Processing". + "Failed", "Succeeded", "Suspended", and "Processing". :vartype provisioning_state: str or ~azure.mgmt.automation.models.JobProvisioningState """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'runbook': {'key': 'properties.runbook', 'type': 'RunbookAssociationProperty'}, - 'started_by': {'key': 'properties.startedBy', 'type': 'str'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, - 'job_id': {'key': 'properties.jobId', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'status': {'key': 'properties.status', 'type': 'str'}, - 'status_details': {'key': 'properties.statusDetails', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'properties.endTime', 'type': 'iso-8601'}, - 'exception': {'key': 'properties.exception', 'type': 'str'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'last_status_modified_time': {'key': 'properties.lastStatusModifiedTime', 'type': 'iso-8601'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "runbook": {"key": "properties.runbook", "type": "RunbookAssociationProperty"}, + "started_by": {"key": "properties.startedBy", "type": "str"}, + "run_on": {"key": "properties.runOn", "type": "str"}, + "job_id": {"key": "properties.jobId", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "status": {"key": "properties.status", "type": "str"}, + "status_details": {"key": "properties.statusDetails", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "end_time": {"key": "properties.endTime", "type": "iso-8601"}, + "exception": {"key": "properties.exception", "type": "str"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "last_status_modified_time": {"key": "properties.lastStatusModifiedTime", "type": "iso-8601"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, } def __init__( @@ -4069,7 +3927,7 @@ def __init__( :paramtype creation_time: ~datetime.datetime :keyword status: Gets or sets the status of the job. Known values are: "New", "Activating", "Running", "Completed", "Failed", "Stopped", "Blocked", "Suspended", "Disconnected", - "Suspending", "Stopping", "Resuming", "Removing". + "Suspending", "Stopping", "Resuming", and "Removing". :paramtype status: str or ~azure.mgmt.automation.models.JobStatus :keyword status_details: Gets or sets the status details of the job. :paramtype status_details: str @@ -4086,10 +3944,10 @@ def __init__( :keyword parameters: Gets or sets the parameters of the job. :paramtype parameters: dict[str, str] :keyword provisioning_state: The current provisioning state of the job. Known values are: - "Failed", "Succeeded", "Suspended", "Processing". + "Failed", "Succeeded", "Suspended", and "Processing". :paramtype provisioning_state: str or ~azure.mgmt.automation.models.JobProvisioningState """ - super(Job, self).__init__(**kwargs) + super().__init__(**kwargs) self.runbook = runbook self.started_by = started_by self.run_on = run_on @@ -4106,7 +3964,7 @@ def __init__( self.provisioning_state = provisioning_state -class JobCollectionItem(ProxyResource): +class JobCollectionItem(ProxyResource): # pylint: disable=too-many-instance-attributes """Job collection item properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -4125,7 +3983,7 @@ class JobCollectionItem(ProxyResource): :vartype creation_time: ~datetime.datetime :ivar status: The status of the job. Known values are: "New", "Activating", "Running", "Completed", "Failed", "Stopped", "Blocked", "Suspended", "Disconnected", "Suspending", - "Stopping", "Resuming", "Removing". + "Stopping", "Resuming", and "Removing". :vartype status: str or ~azure.mgmt.automation.models.JobStatus :ivar start_time: The start time of the job. :vartype start_time: ~datetime.datetime @@ -4140,45 +3998,40 @@ class JobCollectionItem(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'runbook': {'readonly': True}, - 'job_id': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'status': {'readonly': True}, - 'start_time': {'readonly': True}, - 'end_time': {'readonly': True}, - 'last_modified_time': {'readonly': True}, - 'provisioning_state': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'runbook': {'key': 'properties.runbook', 'type': 'RunbookAssociationProperty'}, - 'job_id': {'key': 'properties.jobId', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'status': {'key': 'properties.status', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'properties.endTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, - } - - def __init__( - self, - *, - run_on: Optional[str] = None, - **kwargs - ): + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "runbook": {"readonly": True}, + "job_id": {"readonly": True}, + "creation_time": {"readonly": True}, + "status": {"readonly": True}, + "start_time": {"readonly": True}, + "end_time": {"readonly": True}, + "last_modified_time": {"readonly": True}, + "provisioning_state": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "runbook": {"key": "properties.runbook", "type": "RunbookAssociationProperty"}, + "job_id": {"key": "properties.jobId", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "status": {"key": "properties.status", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "end_time": {"key": "properties.endTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "run_on": {"key": "properties.runOn", "type": "str"}, + } + + def __init__(self, *, run_on: Optional[str] = None, **kwargs): """ :keyword run_on: Specifies the runOn group name where the job was executed. :paramtype run_on: str """ - super(JobCollectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.runbook = None self.job_id = None self.creation_time = None @@ -4190,7 +4043,7 @@ def __init__( self.run_on = run_on -class JobCreateParameters(msrest.serialization.Model): +class JobCreateParameters(_serialization.Model): """The parameters supplied to the create job operation. :ivar runbook: Gets or sets the runbook. @@ -4203,9 +4056,9 @@ class JobCreateParameters(msrest.serialization.Model): """ _attribute_map = { - 'runbook': {'key': 'properties.runbook', 'type': 'RunbookAssociationProperty'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, + "runbook": {"key": "properties.runbook", "type": "RunbookAssociationProperty"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, + "run_on": {"key": "properties.runOn", "type": "str"}, } def __init__( @@ -4225,13 +4078,13 @@ def __init__( executed. :paramtype run_on: str """ - super(JobCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.runbook = runbook self.parameters = parameters self.run_on = run_on -class JobListResultV2(msrest.serialization.Model): +class JobListResultV2(_serialization.Model): """The response model for the list job operation. Variables are only populated by the server, and will be ignored when sending a request. @@ -4243,30 +4096,25 @@ class JobListResultV2(msrest.serialization.Model): """ _validation = { - 'next_link': {'readonly': True}, + "next_link": {"readonly": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': '[JobCollectionItem]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[JobCollectionItem]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.JobCollectionItem"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.JobCollectionItem"]] = None, **kwargs): """ :keyword value: List of jobs. :paramtype value: list[~azure.mgmt.automation.models.JobCollectionItem] """ - super(JobListResultV2, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = None -class JobNavigation(msrest.serialization.Model): +class JobNavigation(_serialization.Model): """Software update configuration machine run job navigation properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -4276,24 +4124,20 @@ class JobNavigation(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(JobNavigation, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None -class JobSchedule(msrest.serialization.Model): +class JobSchedule(_serialization.Model): """Definition of the job schedule. Variables are only populated by the server, and will be ignored when sending a request. @@ -4317,20 +4161,20 @@ class JobSchedule(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'job_schedule_id': {'key': 'properties.jobScheduleId', 'type': 'str'}, - 'schedule': {'key': 'properties.schedule', 'type': 'ScheduleAssociationProperty'}, - 'runbook': {'key': 'properties.runbook', 'type': 'RunbookAssociationProperty'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "job_schedule_id": {"key": "properties.jobScheduleId", "type": "str"}, + "schedule": {"key": "properties.schedule", "type": "ScheduleAssociationProperty"}, + "runbook": {"key": "properties.runbook", "type": "RunbookAssociationProperty"}, + "run_on": {"key": "properties.runOn", "type": "str"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, } def __init__( @@ -4355,7 +4199,7 @@ def __init__( :keyword parameters: Gets or sets the parameters of the job schedule. :paramtype parameters: dict[str, str] """ - super(JobSchedule, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.name = None self.type = None @@ -4366,14 +4210,14 @@ def __init__( self.parameters = parameters -class JobScheduleCreateParameters(msrest.serialization.Model): +class JobScheduleCreateParameters(_serialization.Model): """The parameters supplied to the create job schedule operation. All required parameters must be populated in order to send to Azure. - :ivar schedule: Required. Gets or sets the schedule. + :ivar schedule: Gets or sets the schedule. Required. :vartype schedule: ~azure.mgmt.automation.models.ScheduleAssociationProperty - :ivar runbook: Required. Gets or sets the runbook. + :ivar runbook: Gets or sets the runbook. Required. :vartype runbook: ~azure.mgmt.automation.models.RunbookAssociationProperty :ivar run_on: Gets or sets the hybrid worker group that the scheduled job should run on. :vartype run_on: str @@ -4382,15 +4226,15 @@ class JobScheduleCreateParameters(msrest.serialization.Model): """ _validation = { - 'schedule': {'required': True}, - 'runbook': {'required': True}, + "schedule": {"required": True}, + "runbook": {"required": True}, } _attribute_map = { - 'schedule': {'key': 'properties.schedule', 'type': 'ScheduleAssociationProperty'}, - 'runbook': {'key': 'properties.runbook', 'type': 'RunbookAssociationProperty'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, + "schedule": {"key": "properties.schedule", "type": "ScheduleAssociationProperty"}, + "runbook": {"key": "properties.runbook", "type": "RunbookAssociationProperty"}, + "run_on": {"key": "properties.runOn", "type": "str"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, } def __init__( @@ -4403,23 +4247,23 @@ def __init__( **kwargs ): """ - :keyword schedule: Required. Gets or sets the schedule. + :keyword schedule: Gets or sets the schedule. Required. :paramtype schedule: ~azure.mgmt.automation.models.ScheduleAssociationProperty - :keyword runbook: Required. Gets or sets the runbook. + :keyword runbook: Gets or sets the runbook. Required. :paramtype runbook: ~azure.mgmt.automation.models.RunbookAssociationProperty :keyword run_on: Gets or sets the hybrid worker group that the scheduled job should run on. :paramtype run_on: str :keyword parameters: Gets or sets a list of job properties. :paramtype parameters: dict[str, str] """ - super(JobScheduleCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.schedule = schedule self.runbook = runbook self.run_on = run_on self.parameters = parameters -class JobScheduleListResult(msrest.serialization.Model): +class JobScheduleListResult(_serialization.Model): """The response model for the list job schedule operation. :ivar value: Gets or sets a list of job schedules. @@ -4429,16 +4273,12 @@ class JobScheduleListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[JobSchedule]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[JobSchedule]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.JobSchedule"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.JobSchedule"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: Gets or sets a list of job schedules. @@ -4446,12 +4286,12 @@ def __init__( :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(JobScheduleListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class JobStream(msrest.serialization.Model): +class JobStream(_serialization.Model): """Definition of the job stream. :ivar id: Gets or sets the id of the resource. @@ -4461,36 +4301,36 @@ class JobStream(msrest.serialization.Model): :ivar time: Gets or sets the creation time of the job. :vartype time: ~datetime.datetime :ivar stream_type: Gets or sets the stream type. Known values are: "Progress", "Output", - "Warning", "Error", "Debug", "Verbose", "Any". + "Warning", "Error", "Debug", "Verbose", and "Any". :vartype stream_type: str or ~azure.mgmt.automation.models.JobStreamType :ivar stream_text: Gets or sets the stream text. :vartype stream_text: str :ivar summary: Gets or sets the summary. :vartype summary: str :ivar value: Gets or sets the values of the job stream. - :vartype value: dict[str, any] + :vartype value: dict[str, JSON] """ _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'job_stream_id': {'key': 'properties.jobStreamId', 'type': 'str'}, - 'time': {'key': 'properties.time', 'type': 'iso-8601'}, - 'stream_type': {'key': 'properties.streamType', 'type': 'str'}, - 'stream_text': {'key': 'properties.streamText', 'type': 'str'}, - 'summary': {'key': 'properties.summary', 'type': 'str'}, - 'value': {'key': 'properties.value', 'type': '{object}'}, + "id": {"key": "id", "type": "str"}, + "job_stream_id": {"key": "properties.jobStreamId", "type": "str"}, + "time": {"key": "properties.time", "type": "iso-8601"}, + "stream_type": {"key": "properties.streamType", "type": "str"}, + "stream_text": {"key": "properties.streamText", "type": "str"}, + "summary": {"key": "properties.summary", "type": "str"}, + "value": {"key": "properties.value", "type": "{object}"}, } def __init__( self, *, - id: Optional[str] = None, + id: Optional[str] = None, # pylint: disable=redefined-builtin job_stream_id: Optional[str] = None, time: Optional[datetime.datetime] = None, stream_type: Optional[Union[str, "_models.JobStreamType"]] = None, stream_text: Optional[str] = None, summary: Optional[str] = None, - value: Optional[Dict[str, Any]] = None, + value: Optional[Dict[str, JSON]] = None, **kwargs ): """ @@ -4501,16 +4341,16 @@ def __init__( :keyword time: Gets or sets the creation time of the job. :paramtype time: ~datetime.datetime :keyword stream_type: Gets or sets the stream type. Known values are: "Progress", "Output", - "Warning", "Error", "Debug", "Verbose", "Any". + "Warning", "Error", "Debug", "Verbose", and "Any". :paramtype stream_type: str or ~azure.mgmt.automation.models.JobStreamType :keyword stream_text: Gets or sets the stream text. :paramtype stream_text: str :keyword summary: Gets or sets the summary. :paramtype summary: str :keyword value: Gets or sets the values of the job stream. - :paramtype value: dict[str, any] + :paramtype value: dict[str, JSON] """ - super(JobStream, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.job_stream_id = job_stream_id self.time = time @@ -4520,7 +4360,7 @@ def __init__( self.value = value -class JobStreamListResult(msrest.serialization.Model): +class JobStreamListResult(_serialization.Model): """The response model for the list job stream operation. :ivar value: A list of job streams. @@ -4530,66 +4370,56 @@ class JobStreamListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[JobStream]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[JobStream]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.JobStream"]] = None, - next_link: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.JobStream"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: A list of job streams. :paramtype value: list[~azure.mgmt.automation.models.JobStream] :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(JobStreamListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class Key(msrest.serialization.Model): +class Key(_serialization.Model): """Automation key which is used to register a DSC Node. Variables are only populated by the server, and will be ignored when sending a request. - :ivar key_name: Automation key name. Known values are: "Primary", "Secondary". + :ivar key_name: Automation key name. Known values are: "Primary" and "Secondary". :vartype key_name: str or ~azure.mgmt.automation.models.AutomationKeyName - :ivar permissions: Automation key permissions. Known values are: "Read", "Full". + :ivar permissions: Automation key permissions. Known values are: "Read" and "Full". :vartype permissions: str or ~azure.mgmt.automation.models.AutomationKeyPermissions :ivar value: Value of the Automation Key used for registration. :vartype value: str """ _validation = { - 'key_name': {'readonly': True}, - 'permissions': {'readonly': True}, - 'value': {'readonly': True}, + "key_name": {"readonly": True}, + "permissions": {"readonly": True}, + "value": {"readonly": True}, } _attribute_map = { - 'key_name': {'key': 'KeyName', 'type': 'str'}, - 'permissions': {'key': 'Permissions', 'type': 'str'}, - 'value': {'key': 'Value', 'type': 'str'}, + "key_name": {"key": "KeyName", "type": "str"}, + "permissions": {"key": "Permissions", "type": "str"}, + "value": {"key": "Value", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(Key, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.key_name = None self.permissions = None self.value = None -class KeyListResult(msrest.serialization.Model): +class KeyListResult(_serialization.Model): """KeyListResult. :ivar keys: Lists the automation keys. @@ -4597,24 +4427,19 @@ class KeyListResult(msrest.serialization.Model): """ _attribute_map = { - 'keys': {'key': 'keys', 'type': '[Key]'}, + "keys": {"key": "keys", "type": "[Key]"}, } - def __init__( - self, - *, - keys: Optional[List["_models.Key"]] = None, - **kwargs - ): + def __init__(self, *, keys: Optional[List["_models.Key"]] = None, **kwargs): """ :keyword keys: Lists the automation keys. :paramtype keys: list[~azure.mgmt.automation.models.Key] """ - super(KeyListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.keys = keys -class KeyVaultProperties(msrest.serialization.Model): +class KeyVaultProperties(_serialization.Model): """Settings concerning key vault encryption for a configuration store. :ivar keyvault_uri: The URI of the key vault key used to encrypt data. @@ -4626,9 +4451,9 @@ class KeyVaultProperties(msrest.serialization.Model): """ _attribute_map = { - 'keyvault_uri': {'key': 'keyvaultUri', 'type': 'str'}, - 'key_name': {'key': 'keyName', 'type': 'str'}, - 'key_version': {'key': 'keyVersion', 'type': 'str'}, + "keyvault_uri": {"key": "keyvaultUri", "type": "str"}, + "key_name": {"key": "keyName", "type": "str"}, + "key_version": {"key": "keyVersion", "type": "str"}, } def __init__( @@ -4647,13 +4472,13 @@ def __init__( :keyword key_version: The key version of the key used to encrypt data. :paramtype key_version: str """ - super(KeyVaultProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.keyvault_uri = keyvault_uri self.key_name = key_name self.key_version = key_version -class LinkedWorkspace(msrest.serialization.Model): +class LinkedWorkspace(_serialization.Model): """Definition of the linked workspace. Variables are only populated by the server, and will be ignored when sending a request. @@ -4663,28 +4488,24 @@ class LinkedWorkspace(msrest.serialization.Model): """ _validation = { - 'id': {'readonly': True}, + "id": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(LinkedWorkspace, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.id = None -class LinuxProperties(msrest.serialization.Model): +class LinuxProperties(_serialization.Model): """Linux specific update configuration. :ivar included_package_classifications: Update classifications included in the software update - configuration. Known values are: "Unclassified", "Critical", "Security", "Other". + configuration. Known values are: "Unclassified", "Critical", "Security", and "Other". :vartype included_package_classifications: str or ~azure.mgmt.automation.models.LinuxUpdateClasses :ivar excluded_package_name_masks: packages excluded from the software update configuration. @@ -4696,10 +4517,10 @@ class LinuxProperties(msrest.serialization.Model): """ _attribute_map = { - 'included_package_classifications': {'key': 'includedPackageClassifications', 'type': 'str'}, - 'excluded_package_name_masks': {'key': 'excludedPackageNameMasks', 'type': '[str]'}, - 'included_package_name_masks': {'key': 'includedPackageNameMasks', 'type': '[str]'}, - 'reboot_setting': {'key': 'rebootSetting', 'type': 'str'}, + "included_package_classifications": {"key": "includedPackageClassifications", "type": "str"}, + "excluded_package_name_masks": {"key": "excludedPackageNameMasks", "type": "[str]"}, + "included_package_name_masks": {"key": "includedPackageNameMasks", "type": "[str]"}, + "reboot_setting": {"key": "rebootSetting", "type": "str"}, } def __init__( @@ -4713,7 +4534,7 @@ def __init__( ): """ :keyword included_package_classifications: Update classifications included in the software - update configuration. Known values are: "Unclassified", "Critical", "Security", "Other". + update configuration. Known values are: "Unclassified", "Critical", "Security", and "Other". :paramtype included_package_classifications: str or ~azure.mgmt.automation.models.LinuxUpdateClasses :keyword excluded_package_name_masks: packages excluded from the software update configuration. @@ -4723,14 +4544,113 @@ def __init__( :keyword reboot_setting: Reboot setting for the software update configuration. :paramtype reboot_setting: str """ - super(LinuxProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.included_package_classifications = included_package_classifications self.excluded_package_name_masks = excluded_package_name_masks self.included_package_name_masks = included_package_name_masks self.reboot_setting = reboot_setting -class Module(TrackedResource): +class LogSpecification(_serialization.Model): + """Description of logging specification. + + :ivar name: The name of the specification. + :vartype name: str + :ivar display_name: The display name of the specification. + :vartype display_name: str + :ivar blob_duration: Duration of the blob. + :vartype blob_duration: str + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "blob_duration": {"key": "blobDuration", "type": "str"}, + } + + def __init__( + self, + *, + name: Optional[str] = None, + display_name: Optional[str] = None, + blob_duration: Optional[str] = None, + **kwargs + ): + """ + :keyword name: The name of the specification. + :paramtype name: str + :keyword display_name: The display name of the specification. + :paramtype display_name: str + :keyword blob_duration: Duration of the blob. + :paramtype blob_duration: str + """ + super().__init__(**kwargs) + self.name = name + self.display_name = display_name + self.blob_duration = blob_duration + + +class MetricSpecification(_serialization.Model): + """Description of metrics specification. + + :ivar name: The name of the metric. + :vartype name: str + :ivar display_name: The display name of the metric. + :vartype display_name: str + :ivar display_description: The description of the metric. + :vartype display_description: str + :ivar unit: Units the metric to be displayed in. + :vartype unit: str + :ivar aggregation_type: The aggregation type. + :vartype aggregation_type: str + :ivar dimensions: List of dimensions. + :vartype dimensions: list[~azure.mgmt.automation.models.Dimension] + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "display_description": {"key": "displayDescription", "type": "str"}, + "unit": {"key": "unit", "type": "str"}, + "aggregation_type": {"key": "aggregationType", "type": "str"}, + "dimensions": {"key": "dimensions", "type": "[Dimension]"}, + } + + def __init__( + self, + *, + name: Optional[str] = None, + display_name: Optional[str] = None, + display_description: Optional[str] = None, + unit: Optional[str] = None, + aggregation_type: Optional[str] = None, + dimensions: Optional[List["_models.Dimension"]] = None, + **kwargs + ): + """ + :keyword name: The name of the metric. + :paramtype name: str + :keyword display_name: The display name of the metric. + :paramtype display_name: str + :keyword display_description: The description of the metric. + :paramtype display_description: str + :keyword unit: Units the metric to be displayed in. + :paramtype unit: str + :keyword aggregation_type: The aggregation type. + :paramtype aggregation_type: str + :keyword dimensions: List of dimensions. + :paramtype dimensions: list[~azure.mgmt.automation.models.Dimension] + """ + super().__init__(**kwargs) + self.name = name + self.display_name = display_name + self.display_description = display_description + self.unit = unit + self.aggregation_type = aggregation_type + self.dimensions = dimensions + + +class Module(TrackedResource): # pylint: disable=too-many-instance-attributes """Definition of the module type. Variables are only populated by the server, and will be ignored when sending a request. @@ -4741,7 +4661,7 @@ class Module(TrackedResource): :vartype name: str :ivar type: The type of the resource. :vartype type: str - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar location: The Azure Region where the resource lives. :vartype location: str @@ -4752,14 +4672,14 @@ class Module(TrackedResource): :ivar version: Gets or sets the version of the module. :vartype version: str :ivar size_in_bytes: Gets or sets the size in bytes of the module. - :vartype size_in_bytes: long + :vartype size_in_bytes: int :ivar activity_count: Gets or sets the activity count of the module. :vartype activity_count: int :ivar provisioning_state: Gets or sets the provisioning state of the module. Known values are: "Created", "Creating", "StartingImportModuleRunbook", "RunningImportModuleRunbook", "ContentRetrieved", "ContentDownloaded", "ContentValidated", "ConnectionTypeImported", "ContentStored", "ModuleDataStored", "ActivitiesStored", "ModuleImportRunbookComplete", - "Succeeded", "Failed", "Cancelled", "Updating". + "Succeeded", "Failed", "Cancelled", and "Updating". :vartype provisioning_state: str or ~azure.mgmt.automation.models.ModuleProvisioningState :ivar content_link: Gets or sets the contentLink of the module. :vartype content_link: ~azure.mgmt.automation.models.ContentLink @@ -4776,29 +4696,29 @@ class Module(TrackedResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'location': {'key': 'location', 'type': 'str'}, - 'etag': {'key': 'etag', 'type': 'str'}, - 'is_global': {'key': 'properties.isGlobal', 'type': 'bool'}, - 'version': {'key': 'properties.version', 'type': 'str'}, - 'size_in_bytes': {'key': 'properties.sizeInBytes', 'type': 'long'}, - 'activity_count': {'key': 'properties.activityCount', 'type': 'int'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'content_link': {'key': 'properties.contentLink', 'type': 'ContentLink'}, - 'error': {'key': 'properties.error', 'type': 'ModuleErrorInfo'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'is_composite': {'key': 'properties.isComposite', 'type': 'bool'}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "location": {"key": "location", "type": "str"}, + "etag": {"key": "etag", "type": "str"}, + "is_global": {"key": "properties.isGlobal", "type": "bool"}, + "version": {"key": "properties.version", "type": "str"}, + "size_in_bytes": {"key": "properties.sizeInBytes", "type": "int"}, + "activity_count": {"key": "properties.activityCount", "type": "int"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "content_link": {"key": "properties.contentLink", "type": "ContentLink"}, + "error": {"key": "properties.error", "type": "ModuleErrorInfo"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, + "is_composite": {"key": "properties.isComposite", "type": "bool"}, } def __init__( @@ -4821,7 +4741,7 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword location: The Azure Region where the resource lives. :paramtype location: str @@ -4832,14 +4752,14 @@ def __init__( :keyword version: Gets or sets the version of the module. :paramtype version: str :keyword size_in_bytes: Gets or sets the size in bytes of the module. - :paramtype size_in_bytes: long + :paramtype size_in_bytes: int :keyword activity_count: Gets or sets the activity count of the module. :paramtype activity_count: int :keyword provisioning_state: Gets or sets the provisioning state of the module. Known values are: "Created", "Creating", "StartingImportModuleRunbook", "RunningImportModuleRunbook", "ContentRetrieved", "ContentDownloaded", "ContentValidated", "ConnectionTypeImported", "ContentStored", "ModuleDataStored", "ActivitiesStored", "ModuleImportRunbookComplete", - "Succeeded", "Failed", "Cancelled", "Updating". + "Succeeded", "Failed", "Cancelled", and "Updating". :paramtype provisioning_state: str or ~azure.mgmt.automation.models.ModuleProvisioningState :keyword content_link: Gets or sets the contentLink of the module. :paramtype content_link: ~azure.mgmt.automation.models.ContentLink @@ -4854,7 +4774,7 @@ def __init__( :keyword is_composite: Gets or sets type of module, if its composite or not. :paramtype is_composite: bool """ - super(Module, self).__init__(tags=tags, location=location, **kwargs) + super().__init__(tags=tags, location=location, **kwargs) self.etag = etag self.is_global = is_global self.version = version @@ -4869,7 +4789,7 @@ def __init__( self.is_composite = is_composite -class ModuleCreateOrUpdateParameters(msrest.serialization.Model): +class ModuleCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update module operation. All required parameters must be populated in order to send to Azure. @@ -4878,21 +4798,21 @@ class ModuleCreateOrUpdateParameters(msrest.serialization.Model): :vartype name: str :ivar location: Gets or sets the location of the resource. :vartype location: str - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] - :ivar content_link: Required. Gets or sets the module content link. + :ivar content_link: Gets or sets the module content link. Required. :vartype content_link: ~azure.mgmt.automation.models.ContentLink """ _validation = { - 'content_link': {'required': True}, + "content_link": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'content_link': {'key': 'properties.contentLink', 'type': 'ContentLink'}, + "name": {"key": "name", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "content_link": {"key": "properties.contentLink", "type": "ContentLink"}, } def __init__( @@ -4909,19 +4829,19 @@ def __init__( :paramtype name: str :keyword location: Gets or sets the location of the resource. :paramtype location: str - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] - :keyword content_link: Required. Gets or sets the module content link. + :keyword content_link: Gets or sets the module content link. Required. :paramtype content_link: ~azure.mgmt.automation.models.ContentLink """ - super(ModuleCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.location = location self.tags = tags self.content_link = content_link -class ModuleErrorInfo(msrest.serialization.Model): +class ModuleErrorInfo(_serialization.Model): """Definition of the module error info type. :ivar code: Gets or sets the error code. @@ -4931,29 +4851,23 @@ class ModuleErrorInfo(msrest.serialization.Model): """ _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, } - def __init__( - self, - *, - code: Optional[str] = None, - message: Optional[str] = None, - **kwargs - ): + def __init__(self, *, code: Optional[str] = None, message: Optional[str] = None, **kwargs): """ :keyword code: Gets or sets the error code. :paramtype code: str :keyword message: Gets or sets the error message. :paramtype message: str """ - super(ModuleErrorInfo, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message -class ModuleListResult(msrest.serialization.Model): +class ModuleListResult(_serialization.Model): """The response model for the list module operation. :ivar value: Gets or sets a list of modules. @@ -4963,46 +4877,40 @@ class ModuleListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Module]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Module]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.Module"]] = None, - next_link: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Module"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: Gets or sets a list of modules. :paramtype value: list[~azure.mgmt.automation.models.Module] :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(ModuleListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ModuleUpdateParameters(msrest.serialization.Model): +class ModuleUpdateParameters(_serialization.Model): """The parameters supplied to the update module operation. :ivar name: Gets or sets name of the resource. :vartype name: str :ivar location: Gets or sets the location of the resource. :vartype location: str - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] :ivar content_link: Gets or sets the module content link. :vartype content_link: ~azure.mgmt.automation.models.ContentLink """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'content_link': {'key': 'properties.contentLink', 'type': 'ContentLink'}, + "name": {"key": "name", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "content_link": {"key": "properties.contentLink", "type": "ContentLink"}, } def __init__( @@ -5019,19 +4927,19 @@ def __init__( :paramtype name: str :keyword location: Gets or sets the location of the resource. :paramtype location: str - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] :keyword content_link: Gets or sets the module content link. :paramtype content_link: ~azure.mgmt.automation.models.ContentLink """ - super(ModuleUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.location = location self.tags = tags self.content_link = content_link -class NodeCount(msrest.serialization.Model): +class NodeCount(_serialization.Model): """Number of nodes based on the Filter. :ivar name: Gets the name of a count type. @@ -5041,16 +4949,12 @@ class NodeCount(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'properties': {'key': 'properties', 'type': 'NodeCountProperties'}, + "name": {"key": "name", "type": "str"}, + "properties": {"key": "properties", "type": "NodeCountProperties"}, } def __init__( - self, - *, - name: Optional[str] = None, - properties: Optional["_models.NodeCountProperties"] = None, - **kwargs + self, *, name: Optional[str] = None, properties: Optional["_models.NodeCountProperties"] = None, **kwargs ): """ :keyword name: Gets the name of a count type. @@ -5058,37 +4962,32 @@ def __init__( :keyword properties: :paramtype properties: ~azure.mgmt.automation.models.NodeCountProperties """ - super(NodeCount, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.properties = properties -class NodeCountProperties(msrest.serialization.Model): +class NodeCountProperties(_serialization.Model): """NodeCountProperties. :ivar count: Gets the count for the name. :vartype count: int """ - - _attribute_map = { - 'count': {'key': 'count', 'type': 'int'}, - } - - def __init__( - self, - *, - count: Optional[int] = None, - **kwargs - ): + + _attribute_map = { + "count": {"key": "count", "type": "int"}, + } + + def __init__(self, *, count: Optional[int] = None, **kwargs): """ :keyword count: Gets the count for the name. :paramtype count: int """ - super(NodeCountProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.count = count -class NodeCounts(msrest.serialization.Model): +class NodeCounts(_serialization.Model): """Gets the count of nodes by count type. :ivar value: Gets an array of counts. @@ -5098,16 +4997,12 @@ class NodeCounts(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[NodeCount]'}, - 'total_count': {'key': 'totalCount', 'type': 'int'}, + "value": {"key": "value", "type": "[NodeCount]"}, + "total_count": {"key": "totalCount", "type": "int"}, } def __init__( - self, - *, - value: Optional[List["_models.NodeCount"]] = None, - total_count: Optional[int] = None, - **kwargs + self, *, value: Optional[List["_models.NodeCount"]] = None, total_count: Optional[int] = None, **kwargs ): """ :keyword value: Gets an array of counts. @@ -5115,12 +5010,12 @@ def __init__( :keyword total_count: Gets the total number of records matching countType criteria. :paramtype total_count: int """ - super(NodeCounts, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.total_count = total_count -class NonAzureQueryProperties(msrest.serialization.Model): +class NonAzureQueryProperties(_serialization.Model): """Non Azure query for the update configuration. :ivar function_alias: Log Analytics Saved Search name. @@ -5130,40 +5025,44 @@ class NonAzureQueryProperties(msrest.serialization.Model): """ _attribute_map = { - 'function_alias': {'key': 'functionAlias', 'type': 'str'}, - 'workspace_id': {'key': 'workspaceId', 'type': 'str'}, + "function_alias": {"key": "functionAlias", "type": "str"}, + "workspace_id": {"key": "workspaceId", "type": "str"}, } - def __init__( - self, - *, - function_alias: Optional[str] = None, - workspace_id: Optional[str] = None, - **kwargs - ): + def __init__(self, *, function_alias: Optional[str] = None, workspace_id: Optional[str] = None, **kwargs): """ :keyword function_alias: Log Analytics Saved Search name. :paramtype function_alias: str :keyword workspace_id: Workspace Id for Log Analytics in which the saved Search is resided. :paramtype workspace_id: str """ - super(NonAzureQueryProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.function_alias = function_alias self.workspace_id = workspace_id -class Operation(msrest.serialization.Model): +class Operation(_serialization.Model): """Automation REST API operation. :ivar name: Operation name: {provider}/{resource}/{operation}. :vartype name: str :ivar display: Provider, Resource and Operation values. :vartype display: ~azure.mgmt.automation.models.OperationDisplay + :ivar origin: Origin of the operation. + :vartype origin: str + :ivar service_specification: Specification of the service. + :vartype service_specification: + ~azure.mgmt.automation.models.OperationPropertiesFormatServiceSpecification """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'display': {'key': 'display', 'type': 'OperationDisplay'}, + "name": {"key": "name", "type": "str"}, + "display": {"key": "display", "type": "OperationDisplay"}, + "origin": {"key": "origin", "type": "str"}, + "service_specification": { + "key": "properties.serviceSpecification", + "type": "OperationPropertiesFormatServiceSpecification", + }, } def __init__( @@ -5171,6 +5070,8 @@ def __init__( *, name: Optional[str] = None, display: Optional["_models.OperationDisplay"] = None, + origin: Optional[str] = None, + service_specification: Optional["_models.OperationPropertiesFormatServiceSpecification"] = None, **kwargs ): """ @@ -5178,13 +5079,20 @@ def __init__( :paramtype name: str :keyword display: Provider, Resource and Operation values. :paramtype display: ~azure.mgmt.automation.models.OperationDisplay + :keyword origin: Origin of the operation. + :paramtype origin: str + :keyword service_specification: Specification of the service. + :paramtype service_specification: + ~azure.mgmt.automation.models.OperationPropertiesFormatServiceSpecification """ - super(Operation, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.display = display + self.origin = origin + self.service_specification = service_specification -class OperationDisplay(msrest.serialization.Model): +class OperationDisplay(_serialization.Model): """Provider, Resource and Operation values. :ivar provider: Service provider: Microsoft.Automation. @@ -5193,12 +5101,15 @@ class OperationDisplay(msrest.serialization.Model): :vartype resource: str :ivar operation: Operation type: Read, write, delete, etc. :vartype operation: str + :ivar description: Description of the operation. + :vartype description: str """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, + "provider": {"key": "provider", "type": "str"}, + "resource": {"key": "resource", "type": "str"}, + "operation": {"key": "operation", "type": "str"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -5207,6 +5118,7 @@ def __init__( provider: Optional[str] = None, resource: Optional[str] = None, operation: Optional[str] = None, + description: Optional[str] = None, **kwargs ): """ @@ -5216,14 +5128,17 @@ def __init__( :paramtype resource: str :keyword operation: Operation type: Read, write, delete, etc. :paramtype operation: str + :keyword description: Description of the operation. + :paramtype description: str """ - super(OperationDisplay, self).__init__(**kwargs) + super().__init__(**kwargs) self.provider = provider self.resource = resource self.operation = operation + self.description = description -class OperationListResult(msrest.serialization.Model): +class OperationListResult(_serialization.Model): """The response model for the list of Automation operations. :ivar value: List of Automation operations supported by the Automation resource provider. @@ -5231,21 +5146,48 @@ class OperationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Operation]'}, + "value": {"key": "value", "type": "[Operation]"}, + } + + def __init__(self, *, value: Optional[List["_models.Operation"]] = None, **kwargs): + """ + :keyword value: List of Automation operations supported by the Automation resource provider. + :paramtype value: list[~azure.mgmt.automation.models.Operation] + """ + super().__init__(**kwargs) + self.value = value + + +class OperationPropertiesFormatServiceSpecification(_serialization.Model): + """Specification of the service. + + :ivar metric_specifications: Operation service specification. + :vartype metric_specifications: list[~azure.mgmt.automation.models.MetricSpecification] + :ivar log_specifications: Operation log specification. + :vartype log_specifications: list[~azure.mgmt.automation.models.LogSpecification] + """ + + _attribute_map = { + "metric_specifications": {"key": "metricSpecifications", "type": "[MetricSpecification]"}, + "log_specifications": {"key": "logSpecifications", "type": "[LogSpecification]"}, } def __init__( self, *, - value: Optional[List["_models.Operation"]] = None, + metric_specifications: Optional[List["_models.MetricSpecification"]] = None, + log_specifications: Optional[List["_models.LogSpecification"]] = None, **kwargs ): """ - :keyword value: List of Automation operations supported by the Automation resource provider. - :paramtype value: list[~azure.mgmt.automation.models.Operation] + :keyword metric_specifications: Operation service specification. + :paramtype metric_specifications: list[~azure.mgmt.automation.models.MetricSpecification] + :keyword log_specifications: Operation log specification. + :paramtype log_specifications: list[~azure.mgmt.automation.models.LogSpecification] """ - super(OperationListResult, self).__init__(**kwargs) - self.value = value + super().__init__(**kwargs) + self.metric_specifications = metric_specifications + self.log_specifications = log_specifications class PrivateEndpointConnection(ProxyResource): @@ -5270,18 +5212,21 @@ class PrivateEndpointConnection(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'private_endpoint': {'key': 'properties.privateEndpoint', 'type': 'PrivateEndpointProperty'}, - 'group_ids': {'key': 'properties.groupIds', 'type': '[str]'}, - 'private_link_service_connection_state': {'key': 'properties.privateLinkServiceConnectionState', 'type': 'PrivateLinkServiceConnectionStateProperty'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "private_endpoint": {"key": "properties.privateEndpoint", "type": "PrivateEndpointProperty"}, + "group_ids": {"key": "properties.groupIds", "type": "[str]"}, + "private_link_service_connection_state": { + "key": "properties.privateLinkServiceConnectionState", + "type": "PrivateLinkServiceConnectionStateProperty", + }, } def __init__( @@ -5302,13 +5247,13 @@ def __init__( :paramtype private_link_service_connection_state: ~azure.mgmt.automation.models.PrivateLinkServiceConnectionStateProperty """ - super(PrivateEndpointConnection, self).__init__(**kwargs) + super().__init__(**kwargs) self.private_endpoint = private_endpoint self.group_ids = group_ids self.private_link_service_connection_state = private_link_service_connection_state -class PrivateEndpointConnectionListResult(msrest.serialization.Model): +class PrivateEndpointConnectionListResult(_serialization.Model): """A list of private endpoint connections. :ivar value: Array of private endpoint connections. @@ -5316,24 +5261,19 @@ class PrivateEndpointConnectionListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateEndpointConnection]'}, + "value": {"key": "value", "type": "[PrivateEndpointConnection]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateEndpointConnection"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateEndpointConnection"]] = None, **kwargs): """ :keyword value: Array of private endpoint connections. :paramtype value: list[~azure.mgmt.automation.models.PrivateEndpointConnection] """ - super(PrivateEndpointConnectionListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateEndpointProperty(msrest.serialization.Model): +class PrivateEndpointProperty(_serialization.Model): """Private endpoint which the connection belongs to. :ivar id: Resource id of the private endpoint. @@ -5341,20 +5281,15 @@ class PrivateEndpointProperty(msrest.serialization.Model): """ _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - *, - id: Optional[str] = None, - **kwargs - ): + def __init__(self, *, id: Optional[str] = None, **kwargs): # pylint: disable=redefined-builtin """ :keyword id: Resource id of the private endpoint. :paramtype id: str """ - super(PrivateEndpointProperty, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id @@ -5376,33 +5311,29 @@ class PrivateLinkResource(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'group_id': {'readonly': True}, - 'required_members': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "group_id": {"readonly": True}, + "required_members": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'group_id': {'key': 'properties.groupId', 'type': 'str'}, - 'required_members': {'key': 'properties.requiredMembers', 'type': '[str]'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "group_id": {"key": "properties.groupId", "type": "str"}, + "required_members": {"key": "properties.requiredMembers", "type": "[str]"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(PrivateLinkResource, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.group_id = None self.required_members = None -class PrivateLinkResourceListResult(msrest.serialization.Model): +class PrivateLinkResourceListResult(_serialization.Model): """A list of private link resources. :ivar value: Array of private link resources. @@ -5410,24 +5341,19 @@ class PrivateLinkResourceListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[PrivateLinkResource]'}, + "value": {"key": "value", "type": "[PrivateLinkResource]"}, } - def __init__( - self, - *, - value: Optional[List["_models.PrivateLinkResource"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.PrivateLinkResource"]] = None, **kwargs): """ :keyword value: Array of private link resources. :paramtype value: list[~azure.mgmt.automation.models.PrivateLinkResource] """ - super(PrivateLinkResourceListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class PrivateLinkServiceConnectionStateProperty(msrest.serialization.Model): +class PrivateLinkServiceConnectionStateProperty(_serialization.Model): """Connection State of the Private Endpoint Connection. Variables are only populated by the server, and will be ignored when sending a request. @@ -5442,113 +5368,96 @@ class PrivateLinkServiceConnectionStateProperty(msrest.serialization.Model): """ _validation = { - 'actions_required': {'readonly': True}, + "actions_required": {"readonly": True}, } _attribute_map = { - 'status': {'key': 'status', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, - 'actions_required': {'key': 'actionsRequired', 'type': 'str'}, + "status": {"key": "status", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "actions_required": {"key": "actionsRequired", "type": "str"}, } - def __init__( - self, - *, - status: Optional[str] = None, - description: Optional[str] = None, - **kwargs - ): + def __init__(self, *, status: Optional[str] = None, description: Optional[str] = None, **kwargs): """ :keyword status: The private link service connection status. :paramtype status: str :keyword description: The private link service connection description. :paramtype description: str """ - super(PrivateLinkServiceConnectionStateProperty, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.description = description self.actions_required = None -class PythonPackageCreateParameters(msrest.serialization.Model): +class PythonPackageCreateParameters(_serialization.Model): """The parameters supplied to the create or update module operation. All required parameters must be populated in order to send to Azure. - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] - :ivar content_link: Required. Gets or sets the module content link. + :ivar content_link: Gets or sets the module content link. Required. :vartype content_link: ~azure.mgmt.automation.models.ContentLink """ _validation = { - 'content_link': {'required': True}, + "content_link": {"required": True}, } _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, - 'content_link': {'key': 'properties.contentLink', 'type': 'ContentLink'}, + "tags": {"key": "tags", "type": "{str}"}, + "content_link": {"key": "properties.contentLink", "type": "ContentLink"}, } - def __init__( - self, - *, - content_link: "_models.ContentLink", - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, content_link: "_models.ContentLink", tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] - :keyword content_link: Required. Gets or sets the module content link. + :keyword content_link: Gets or sets the module content link. Required. :paramtype content_link: ~azure.mgmt.automation.models.ContentLink """ - super(PythonPackageCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.content_link = content_link -class PythonPackageUpdateParameters(msrest.serialization.Model): +class PythonPackageUpdateParameters(_serialization.Model): """The parameters supplied to the update module operation. - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] """ _attribute_map = { - 'tags': {'key': 'tags', 'type': '{str}'}, + "tags": {"key": "tags", "type": "{str}"}, } - def __init__( - self, - *, - tags: Optional[Dict[str, str]] = None, - **kwargs - ): + def __init__(self, *, tags: Optional[Dict[str, str]] = None, **kwargs): """ - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] """ - super(PythonPackageUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags -class RawGraphicalRunbookContent(msrest.serialization.Model): +class RawGraphicalRunbookContent(_serialization.Model): """Raw Graphical Runbook content. :ivar schema_version: Schema version of the serializer. :vartype schema_version: str :ivar runbook_definition: Serialized Graphical runbook. :vartype runbook_definition: str - :ivar runbook_type: Runbook Type. Known values are: "GraphPowerShell", + :ivar runbook_type: Runbook Type. Known values are: "GraphPowerShell" and "GraphPowerShellWorkflow". :vartype runbook_type: str or ~azure.mgmt.automation.models.GraphRunbookType """ _attribute_map = { - 'schema_version': {'key': 'schemaVersion', 'type': 'str'}, - 'runbook_definition': {'key': 'runbookDefinition', 'type': 'str'}, - 'runbook_type': {'key': 'runbookType', 'type': 'str'}, + "schema_version": {"key": "schemaVersion", "type": "str"}, + "runbook_definition": {"key": "runbookDefinition", "type": "str"}, + "runbook_type": {"key": "runbookType", "type": "str"}, } def __init__( @@ -5564,17 +5473,17 @@ def __init__( :paramtype schema_version: str :keyword runbook_definition: Serialized Graphical runbook. :paramtype runbook_definition: str - :keyword runbook_type: Runbook Type. Known values are: "GraphPowerShell", + :keyword runbook_type: Runbook Type. Known values are: "GraphPowerShell" and "GraphPowerShellWorkflow". :paramtype runbook_type: str or ~azure.mgmt.automation.models.GraphRunbookType """ - super(RawGraphicalRunbookContent, self).__init__(**kwargs) + super().__init__(**kwargs) self.schema_version = schema_version self.runbook_definition = runbook_definition self.runbook_type = runbook_type -class RunAsCredentialAssociationProperty(msrest.serialization.Model): +class RunAsCredentialAssociationProperty(_serialization.Model): """Definition of RunAs credential to use for hybrid worker. :ivar name: Gets or sets the name of the credential. @@ -5582,24 +5491,19 @@ class RunAsCredentialAssociationProperty(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the credential. :paramtype name: str """ - super(RunAsCredentialAssociationProperty, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class Runbook(TrackedResource): +class Runbook(TrackedResource): # pylint: disable=too-many-instance-attributes """Definition of the runbook type. Variables are only populated by the server, and will be ignored when sending a request. @@ -5610,7 +5514,7 @@ class Runbook(TrackedResource): :vartype name: str :ivar type: The type of the resource. :vartype type: str - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar location: The Azure Region where the resource lives. :vartype location: str @@ -5618,11 +5522,11 @@ class Runbook(TrackedResource): :vartype etag: str :ivar runbook_type: Gets or sets the type of the runbook. Known values are: "Script", "Graph", "PowerShellWorkflow", "PowerShell", "GraphPowerShellWorkflow", "GraphPowerShell", "Python2", - "Python3". + and "Python3". :vartype runbook_type: str or ~azure.mgmt.automation.models.RunbookTypeEnum :ivar publish_content_link: Gets or sets the published runbook content link. :vartype publish_content_link: ~azure.mgmt.automation.models.ContentLink - :ivar state: Gets or sets the state of the runbook. Known values are: "New", "Edit", + :ivar state: Gets or sets the state of the runbook. Known values are: "New", "Edit", and "Published". :vartype state: str or ~azure.mgmt.automation.models.RunbookState :ivar log_verbose: Gets or sets verbose log option. @@ -5639,8 +5543,8 @@ class Runbook(TrackedResource): :vartype output_types: list[str] :ivar draft: Gets or sets the draft runbook properties. :vartype draft: ~azure.mgmt.automation.models.RunbookDraft - :ivar provisioning_state: Gets or sets the provisioning state of the runbook. The only - acceptable values to pass in are None and "Succeeded". The default value is None. + :ivar provisioning_state: Gets or sets the provisioning state of the runbook. Default value is + "Succeeded". :vartype provisioning_state: str :ivar last_modified_by: Gets or sets the last modified by. :vartype last_modified_by: str @@ -5653,33 +5557,33 @@ class Runbook(TrackedResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'location': {'key': 'location', 'type': 'str'}, - 'etag': {'key': 'etag', 'type': 'str'}, - 'runbook_type': {'key': 'properties.runbookType', 'type': 'str'}, - 'publish_content_link': {'key': 'properties.publishContentLink', 'type': 'ContentLink'}, - 'state': {'key': 'properties.state', 'type': 'str'}, - 'log_verbose': {'key': 'properties.logVerbose', 'type': 'bool'}, - 'log_progress': {'key': 'properties.logProgress', 'type': 'bool'}, - 'log_activity_trace': {'key': 'properties.logActivityTrace', 'type': 'int'}, - 'job_count': {'key': 'properties.jobCount', 'type': 'int'}, - 'parameters': {'key': 'properties.parameters', 'type': '{RunbookParameter}'}, - 'output_types': {'key': 'properties.outputTypes', 'type': '[str]'}, - 'draft': {'key': 'properties.draft', 'type': 'RunbookDraft'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'last_modified_by': {'key': 'properties.lastModifiedBy', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "location": {"key": "location", "type": "str"}, + "etag": {"key": "etag", "type": "str"}, + "runbook_type": {"key": "properties.runbookType", "type": "str"}, + "publish_content_link": {"key": "properties.publishContentLink", "type": "ContentLink"}, + "state": {"key": "properties.state", "type": "str"}, + "log_verbose": {"key": "properties.logVerbose", "type": "bool"}, + "log_progress": {"key": "properties.logProgress", "type": "bool"}, + "log_activity_trace": {"key": "properties.logActivityTrace", "type": "int"}, + "job_count": {"key": "properties.jobCount", "type": "int"}, + "parameters": {"key": "properties.parameters", "type": "{RunbookParameter}"}, + "output_types": {"key": "properties.outputTypes", "type": "[str]"}, + "draft": {"key": "properties.draft", "type": "RunbookDraft"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "last_modified_by": {"key": "properties.lastModifiedBy", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -5706,7 +5610,7 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword location: The Azure Region where the resource lives. :paramtype location: str @@ -5714,11 +5618,11 @@ def __init__( :paramtype etag: str :keyword runbook_type: Gets or sets the type of the runbook. Known values are: "Script", "Graph", "PowerShellWorkflow", "PowerShell", "GraphPowerShellWorkflow", "GraphPowerShell", - "Python2", "Python3". + "Python2", and "Python3". :paramtype runbook_type: str or ~azure.mgmt.automation.models.RunbookTypeEnum :keyword publish_content_link: Gets or sets the published runbook content link. :paramtype publish_content_link: ~azure.mgmt.automation.models.ContentLink - :keyword state: Gets or sets the state of the runbook. Known values are: "New", "Edit", + :keyword state: Gets or sets the state of the runbook. Known values are: "New", "Edit", and "Published". :paramtype state: str or ~azure.mgmt.automation.models.RunbookState :keyword log_verbose: Gets or sets verbose log option. @@ -5735,8 +5639,8 @@ def __init__( :paramtype output_types: list[str] :keyword draft: Gets or sets the draft runbook properties. :paramtype draft: ~azure.mgmt.automation.models.RunbookDraft - :keyword provisioning_state: Gets or sets the provisioning state of the runbook. The only - acceptable values to pass in are None and "Succeeded". The default value is None. + :keyword provisioning_state: Gets or sets the provisioning state of the runbook. Default value + is "Succeeded". :paramtype provisioning_state: str :keyword last_modified_by: Gets or sets the last modified by. :paramtype last_modified_by: str @@ -5747,7 +5651,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(Runbook, self).__init__(tags=tags, location=location, **kwargs) + super().__init__(tags=tags, location=location, **kwargs) self.etag = etag self.runbook_type = runbook_type self.publish_content_link = publish_content_link @@ -5766,7 +5670,7 @@ def __init__( self.description = description -class RunbookAssociationProperty(msrest.serialization.Model): +class RunbookAssociationProperty(_serialization.Model): """The runbook property associated with the entity. :ivar name: Gets or sets the name of the runbook. @@ -5774,55 +5678,45 @@ class RunbookAssociationProperty(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the runbook. :paramtype name: str """ - super(RunbookAssociationProperty, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class RunbookCreateOrUpdateDraftParameters(msrest.serialization.Model): +class RunbookCreateOrUpdateDraftParameters(_serialization.Model): """The parameters supplied to the create or update runbook operation. All required parameters must be populated in order to send to Azure. - :ivar runbook_content: Required. Content of the Runbook. + :ivar runbook_content: Content of the Runbook. Required. :vartype runbook_content: str """ _validation = { - 'runbook_content': {'required': True}, + "runbook_content": {"required": True}, } _attribute_map = { - 'runbook_content': {'key': 'runbookContent', 'type': 'str'}, + "runbook_content": {"key": "runbookContent", "type": "str"}, } - def __init__( - self, - *, - runbook_content: str, - **kwargs - ): + def __init__(self, *, runbook_content: str, **kwargs): """ - :keyword runbook_content: Required. Content of the Runbook. + :keyword runbook_content: Content of the Runbook. Required. :paramtype runbook_content: str """ - super(RunbookCreateOrUpdateDraftParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.runbook_content = runbook_content -class RunbookCreateOrUpdateDraftProperties(msrest.serialization.Model): +class RunbookCreateOrUpdateDraftProperties(_serialization.Model): """The parameters supplied to the create or update draft runbook properties. All required parameters must be populated in order to send to Azure. @@ -5831,11 +5725,11 @@ class RunbookCreateOrUpdateDraftProperties(msrest.serialization.Model): :vartype log_verbose: bool :ivar log_progress: Gets or sets progress log option. :vartype log_progress: bool - :ivar runbook_type: Required. Gets or sets the type of the runbook. Known values are: "Script", + :ivar runbook_type: Gets or sets the type of the runbook. Required. Known values are: "Script", "Graph", "PowerShellWorkflow", "PowerShell", "GraphPowerShellWorkflow", "GraphPowerShell", - "Python2", "Python3". + "Python2", and "Python3". :vartype runbook_type: str or ~azure.mgmt.automation.models.RunbookTypeEnum - :ivar draft: Required. Gets or sets the draft runbook properties. + :ivar draft: Gets or sets the draft runbook properties. Required. :vartype draft: ~azure.mgmt.automation.models.RunbookDraft :ivar description: Gets or sets the description of the runbook. :vartype description: str @@ -5844,17 +5738,17 @@ class RunbookCreateOrUpdateDraftProperties(msrest.serialization.Model): """ _validation = { - 'runbook_type': {'required': True}, - 'draft': {'required': True}, + "runbook_type": {"required": True}, + "draft": {"required": True}, } _attribute_map = { - 'log_verbose': {'key': 'logVerbose', 'type': 'bool'}, - 'log_progress': {'key': 'logProgress', 'type': 'bool'}, - 'runbook_type': {'key': 'runbookType', 'type': 'str'}, - 'draft': {'key': 'draft', 'type': 'RunbookDraft'}, - 'description': {'key': 'description', 'type': 'str'}, - 'log_activity_trace': {'key': 'logActivityTrace', 'type': 'int'}, + "log_verbose": {"key": "logVerbose", "type": "bool"}, + "log_progress": {"key": "logProgress", "type": "bool"}, + "runbook_type": {"key": "runbookType", "type": "str"}, + "draft": {"key": "draft", "type": "RunbookDraft"}, + "description": {"key": "description", "type": "str"}, + "log_activity_trace": {"key": "logActivityTrace", "type": "int"}, } def __init__( @@ -5873,18 +5767,18 @@ def __init__( :paramtype log_verbose: bool :keyword log_progress: Gets or sets progress log option. :paramtype log_progress: bool - :keyword runbook_type: Required. Gets or sets the type of the runbook. Known values are: + :keyword runbook_type: Gets or sets the type of the runbook. Required. Known values are: "Script", "Graph", "PowerShellWorkflow", "PowerShell", "GraphPowerShellWorkflow", - "GraphPowerShell", "Python2", "Python3". + "GraphPowerShell", "Python2", and "Python3". :paramtype runbook_type: str or ~azure.mgmt.automation.models.RunbookTypeEnum - :keyword draft: Required. Gets or sets the draft runbook properties. + :keyword draft: Gets or sets the draft runbook properties. Required. :paramtype draft: ~azure.mgmt.automation.models.RunbookDraft :keyword description: Gets or sets the description of the runbook. :paramtype description: str :keyword log_activity_trace: Gets or sets the activity-level tracing options of the runbook. :paramtype log_activity_trace: int """ - super(RunbookCreateOrUpdateDraftProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.log_verbose = log_verbose self.log_progress = log_progress self.runbook_type = runbook_type @@ -5893,7 +5787,7 @@ def __init__( self.log_activity_trace = log_activity_trace -class RunbookCreateOrUpdateParameters(msrest.serialization.Model): +class RunbookCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update runbook operation. All required parameters must be populated in order to send to Azure. @@ -5902,15 +5796,15 @@ class RunbookCreateOrUpdateParameters(msrest.serialization.Model): :vartype name: str :ivar location: Gets or sets the location of the resource. :vartype location: str - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] :ivar log_verbose: Gets or sets verbose log option. :vartype log_verbose: bool :ivar log_progress: Gets or sets progress log option. :vartype log_progress: bool - :ivar runbook_type: Required. Gets or sets the type of the runbook. Known values are: "Script", + :ivar runbook_type: Gets or sets the type of the runbook. Required. Known values are: "Script", "Graph", "PowerShellWorkflow", "PowerShell", "GraphPowerShellWorkflow", "GraphPowerShell", - "Python2", "Python3". + "Python2", and "Python3". :vartype runbook_type: str or ~azure.mgmt.automation.models.RunbookTypeEnum :ivar draft: Gets or sets the draft runbook properties. :vartype draft: ~azure.mgmt.automation.models.RunbookDraft @@ -5923,20 +5817,20 @@ class RunbookCreateOrUpdateParameters(msrest.serialization.Model): """ _validation = { - 'runbook_type': {'required': True}, + "runbook_type": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'log_verbose': {'key': 'properties.logVerbose', 'type': 'bool'}, - 'log_progress': {'key': 'properties.logProgress', 'type': 'bool'}, - 'runbook_type': {'key': 'properties.runbookType', 'type': 'str'}, - 'draft': {'key': 'properties.draft', 'type': 'RunbookDraft'}, - 'publish_content_link': {'key': 'properties.publishContentLink', 'type': 'ContentLink'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'log_activity_trace': {'key': 'properties.logActivityTrace', 'type': 'int'}, + "name": {"key": "name", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "log_verbose": {"key": "properties.logVerbose", "type": "bool"}, + "log_progress": {"key": "properties.logProgress", "type": "bool"}, + "runbook_type": {"key": "properties.runbookType", "type": "str"}, + "draft": {"key": "properties.draft", "type": "RunbookDraft"}, + "publish_content_link": {"key": "properties.publishContentLink", "type": "ContentLink"}, + "description": {"key": "properties.description", "type": "str"}, + "log_activity_trace": {"key": "properties.logActivityTrace", "type": "int"}, } def __init__( @@ -5959,15 +5853,15 @@ def __init__( :paramtype name: str :keyword location: Gets or sets the location of the resource. :paramtype location: str - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] :keyword log_verbose: Gets or sets verbose log option. :paramtype log_verbose: bool :keyword log_progress: Gets or sets progress log option. :paramtype log_progress: bool - :keyword runbook_type: Required. Gets or sets the type of the runbook. Known values are: + :keyword runbook_type: Gets or sets the type of the runbook. Required. Known values are: "Script", "Graph", "PowerShellWorkflow", "PowerShell", "GraphPowerShellWorkflow", - "GraphPowerShell", "Python2", "Python3". + "GraphPowerShell", "Python2", and "Python3". :paramtype runbook_type: str or ~azure.mgmt.automation.models.RunbookTypeEnum :keyword draft: Gets or sets the draft runbook properties. :paramtype draft: ~azure.mgmt.automation.models.RunbookDraft @@ -5978,7 +5872,7 @@ def __init__( :keyword log_activity_trace: Gets or sets the activity-level tracing options of the runbook. :paramtype log_activity_trace: int """ - super(RunbookCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.location = location self.tags = tags @@ -5991,7 +5885,7 @@ def __init__( self.log_activity_trace = log_activity_trace -class RunbookDraft(msrest.serialization.Model): +class RunbookDraft(_serialization.Model): """RunbookDraft. :ivar in_edit: Gets or sets whether runbook is in edit mode. @@ -6009,12 +5903,12 @@ class RunbookDraft(msrest.serialization.Model): """ _attribute_map = { - 'in_edit': {'key': 'inEdit', 'type': 'bool'}, - 'draft_content_link': {'key': 'draftContentLink', 'type': 'ContentLink'}, - 'creation_time': {'key': 'creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'lastModifiedTime', 'type': 'iso-8601'}, - 'parameters': {'key': 'parameters', 'type': '{RunbookParameter}'}, - 'output_types': {'key': 'outputTypes', 'type': '[str]'}, + "in_edit": {"key": "inEdit", "type": "bool"}, + "draft_content_link": {"key": "draftContentLink", "type": "ContentLink"}, + "creation_time": {"key": "creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"}, + "parameters": {"key": "parameters", "type": "{RunbookParameter}"}, + "output_types": {"key": "outputTypes", "type": "[str]"}, } def __init__( @@ -6042,7 +5936,7 @@ def __init__( :keyword output_types: Gets or sets the runbook output types. :paramtype output_types: list[str] """ - super(RunbookDraft, self).__init__(**kwargs) + super().__init__(**kwargs) self.in_edit = in_edit self.draft_content_link = draft_content_link self.creation_time = creation_time @@ -6051,7 +5945,7 @@ def __init__( self.output_types = output_types -class RunbookDraftUndoEditResult(msrest.serialization.Model): +class RunbookDraftUndoEditResult(_serialization.Model): """The response model for the undo edit runbook operation. :ivar status_code: Known values are: "Continue", "SwitchingProtocols", "OK", "Created", @@ -6063,15 +5957,15 @@ class RunbookDraftUndoEditResult(msrest.serialization.Model): "LengthRequired", "PreconditionFailed", "RequestEntityTooLarge", "RequestUriTooLong", "UnsupportedMediaType", "RequestedRangeNotSatisfiable", "ExpectationFailed", "UpgradeRequired", "InternalServerError", "NotImplemented", "BadGateway", "ServiceUnavailable", "GatewayTimeout", - "HttpVersionNotSupported". + and "HttpVersionNotSupported". :vartype status_code: str or ~azure.mgmt.automation.models.HttpStatusCode :ivar request_id: :vartype request_id: str """ _attribute_map = { - 'status_code': {'key': 'statusCode', 'type': 'str'}, - 'request_id': {'key': 'requestId', 'type': 'str'}, + "status_code": {"key": "statusCode", "type": "str"}, + "request_id": {"key": "requestId", "type": "str"}, } def __init__( @@ -6091,17 +5985,17 @@ def __init__( "LengthRequired", "PreconditionFailed", "RequestEntityTooLarge", "RequestUriTooLong", "UnsupportedMediaType", "RequestedRangeNotSatisfiable", "ExpectationFailed", "UpgradeRequired", "InternalServerError", "NotImplemented", "BadGateway", "ServiceUnavailable", "GatewayTimeout", - "HttpVersionNotSupported". + and "HttpVersionNotSupported". :paramtype status_code: str or ~azure.mgmt.automation.models.HttpStatusCode :keyword request_id: :paramtype request_id: str """ - super(RunbookDraftUndoEditResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.status_code = status_code self.request_id = request_id -class RunbookListResult(msrest.serialization.Model): +class RunbookListResult(_serialization.Model): """The response model for the list runbook operation. :ivar value: Gets or sets a list of runbooks. @@ -6111,29 +6005,23 @@ class RunbookListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Runbook]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Runbook]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.Runbook"]] = None, - next_link: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Runbook"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: Gets or sets a list of runbooks. :paramtype value: list[~azure.mgmt.automation.models.Runbook] :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(RunbookListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class RunbookParameter(msrest.serialization.Model): +class RunbookParameter(_serialization.Model): """Definition of the runbook parameter type. :ivar type: Gets or sets the type of the parameter. @@ -6148,10 +6036,10 @@ class RunbookParameter(msrest.serialization.Model): """ _attribute_map = { - 'type': {'key': 'type', 'type': 'str'}, - 'is_mandatory': {'key': 'isMandatory', 'type': 'bool'}, - 'position': {'key': 'position', 'type': 'int'}, - 'default_value': {'key': 'defaultValue', 'type': 'str'}, + "type": {"key": "type", "type": "str"}, + "is_mandatory": {"key": "isMandatory", "type": "bool"}, + "position": {"key": "position", "type": "int"}, + "default_value": {"key": "defaultValue", "type": "str"}, } def __init__( @@ -6174,21 +6062,21 @@ def __init__( :keyword default_value: Gets or sets the default value of parameter. :paramtype default_value: str """ - super(RunbookParameter, self).__init__(**kwargs) + super().__init__(**kwargs) self.type = type self.is_mandatory = is_mandatory self.position = position self.default_value = default_value -class RunbookUpdateParameters(msrest.serialization.Model): +class RunbookUpdateParameters(_serialization.Model): """The parameters supplied to the update runbook operation. :ivar name: Gets or sets the name of the resource. :vartype name: str :ivar location: Gets or sets the location of the resource. :vartype location: str - :ivar tags: A set of tags. Gets or sets the tags attached to the resource. + :ivar tags: Gets or sets the tags attached to the resource. :vartype tags: dict[str, str] :ivar description: Gets or sets the description of the runbook. :vartype description: str @@ -6201,13 +6089,13 @@ class RunbookUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'location': {'key': 'location', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'log_verbose': {'key': 'properties.logVerbose', 'type': 'bool'}, - 'log_progress': {'key': 'properties.logProgress', 'type': 'bool'}, - 'log_activity_trace': {'key': 'properties.logActivityTrace', 'type': 'int'}, + "name": {"key": "name", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "description": {"key": "properties.description", "type": "str"}, + "log_verbose": {"key": "properties.logVerbose", "type": "bool"}, + "log_progress": {"key": "properties.logProgress", "type": "bool"}, + "log_activity_trace": {"key": "properties.logActivityTrace", "type": "int"}, } def __init__( @@ -6227,7 +6115,7 @@ def __init__( :paramtype name: str :keyword location: Gets or sets the location of the resource. :paramtype location: str - :keyword tags: A set of tags. Gets or sets the tags attached to the resource. + :keyword tags: Gets or sets the tags attached to the resource. :paramtype tags: dict[str, str] :keyword description: Gets or sets the description of the runbook. :paramtype description: str @@ -6238,7 +6126,7 @@ def __init__( :keyword log_activity_trace: Gets or sets the activity-level tracing options of the runbook. :paramtype log_activity_trace: int """ - super(RunbookUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.location = location self.tags = tags @@ -6248,7 +6136,7 @@ def __init__( self.log_activity_trace = log_activity_trace -class Schedule(ProxyResource): +class Schedule(ProxyResource): # pylint: disable=too-many-instance-attributes """Definition of the schedule. Variables are only populated by the server, and will be ignored when sending a request. @@ -6276,7 +6164,7 @@ class Schedule(ProxyResource): :ivar interval: Gets or sets the interval of the schedule. :vartype interval: any :ivar frequency: Gets or sets the frequency of the schedule. Known values are: "OneTime", - "Day", "Hour", "Week", "Month", "Minute". + "Day", "Hour", "Week", "Month", and "Minute". :vartype frequency: str or ~azure.mgmt.automation.models.ScheduleFrequency :ivar time_zone: Gets or sets the time zone of the schedule. :vartype time_zone: str @@ -6291,30 +6179,30 @@ class Schedule(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'start_time_offset_minutes': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'start_time_offset_minutes': {'key': 'properties.startTimeOffsetMinutes', 'type': 'float'}, - 'expiry_time': {'key': 'properties.expiryTime', 'type': 'iso-8601'}, - 'expiry_time_offset_minutes': {'key': 'properties.expiryTimeOffsetMinutes', 'type': 'float'}, - 'is_enabled': {'key': 'properties.isEnabled', 'type': 'bool'}, - 'next_run': {'key': 'properties.nextRun', 'type': 'iso-8601'}, - 'next_run_offset_minutes': {'key': 'properties.nextRunOffsetMinutes', 'type': 'float'}, - 'interval': {'key': 'properties.interval', 'type': 'object'}, - 'frequency': {'key': 'properties.frequency', 'type': 'str'}, - 'time_zone': {'key': 'properties.timeZone', 'type': 'str'}, - 'advanced_schedule': {'key': 'properties.advancedSchedule', 'type': 'AdvancedSchedule'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "start_time_offset_minutes": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "start_time_offset_minutes": {"key": "properties.startTimeOffsetMinutes", "type": "float"}, + "expiry_time": {"key": "properties.expiryTime", "type": "iso-8601"}, + "expiry_time_offset_minutes": {"key": "properties.expiryTimeOffsetMinutes", "type": "float"}, + "is_enabled": {"key": "properties.isEnabled", "type": "bool"}, + "next_run": {"key": "properties.nextRun", "type": "iso-8601"}, + "next_run_offset_minutes": {"key": "properties.nextRunOffsetMinutes", "type": "float"}, + "interval": {"key": "properties.interval", "type": "object"}, + "frequency": {"key": "properties.frequency", "type": "str"}, + "time_zone": {"key": "properties.timeZone", "type": "str"}, + "advanced_schedule": {"key": "properties.advancedSchedule", "type": "AdvancedSchedule"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -6323,7 +6211,7 @@ def __init__( start_time: Optional[datetime.datetime] = None, expiry_time: Optional[datetime.datetime] = None, expiry_time_offset_minutes: Optional[float] = None, - is_enabled: Optional[bool] = False, + is_enabled: bool = False, next_run: Optional[datetime.datetime] = None, next_run_offset_minutes: Optional[float] = None, interval: Optional[Any] = None, @@ -6351,7 +6239,7 @@ def __init__( :keyword interval: Gets or sets the interval of the schedule. :paramtype interval: any :keyword frequency: Gets or sets the frequency of the schedule. Known values are: "OneTime", - "Day", "Hour", "Week", "Month", "Minute". + "Day", "Hour", "Week", "Month", and "Minute". :paramtype frequency: str or ~azure.mgmt.automation.models.ScheduleFrequency :keyword time_zone: Gets or sets the time zone of the schedule. :paramtype time_zone: str @@ -6364,7 +6252,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(Schedule, self).__init__(**kwargs) + super().__init__(**kwargs) self.start_time = start_time self.start_time_offset_minutes = None self.expiry_time = expiry_time @@ -6381,7 +6269,7 @@ def __init__( self.description = description -class ScheduleAssociationProperty(msrest.serialization.Model): +class ScheduleAssociationProperty(_serialization.Model): """The schedule property associated with the entity. :ivar name: Gets or sets the name of the Schedule. @@ -6389,40 +6277,35 @@ class ScheduleAssociationProperty(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the Schedule. :paramtype name: str """ - super(ScheduleAssociationProperty, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name -class ScheduleCreateOrUpdateParameters(msrest.serialization.Model): +class ScheduleCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update schedule operation. All required parameters must be populated in order to send to Azure. - :ivar name: Required. Gets or sets the name of the Schedule. + :ivar name: Gets or sets the name of the Schedule. Required. :vartype name: str :ivar description: Gets or sets the description of the schedule. :vartype description: str - :ivar start_time: Required. Gets or sets the start time of the schedule. + :ivar start_time: Gets or sets the start time of the schedule. Required. :vartype start_time: ~datetime.datetime :ivar expiry_time: Gets or sets the end time of the schedule. :vartype expiry_time: ~datetime.datetime :ivar interval: Gets or sets the interval of the schedule. :vartype interval: any - :ivar frequency: Required. Gets or sets the frequency of the schedule. Known values are: - "OneTime", "Day", "Hour", "Week", "Month", "Minute". + :ivar frequency: Gets or sets the frequency of the schedule. Required. Known values are: + "OneTime", "Day", "Hour", "Week", "Month", and "Minute". :vartype frequency: str or ~azure.mgmt.automation.models.ScheduleFrequency :ivar time_zone: Gets or sets the time zone of the schedule. :vartype time_zone: str @@ -6431,20 +6314,20 @@ class ScheduleCreateOrUpdateParameters(msrest.serialization.Model): """ _validation = { - 'name': {'required': True}, - 'start_time': {'required': True}, - 'frequency': {'required': True}, + "name": {"required": True}, + "start_time": {"required": True}, + "frequency": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'expiry_time': {'key': 'properties.expiryTime', 'type': 'iso-8601'}, - 'interval': {'key': 'properties.interval', 'type': 'object'}, - 'frequency': {'key': 'properties.frequency', 'type': 'str'}, - 'time_zone': {'key': 'properties.timeZone', 'type': 'str'}, - 'advanced_schedule': {'key': 'properties.advancedSchedule', 'type': 'AdvancedSchedule'}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "expiry_time": {"key": "properties.expiryTime", "type": "iso-8601"}, + "interval": {"key": "properties.interval", "type": "object"}, + "frequency": {"key": "properties.frequency", "type": "str"}, + "time_zone": {"key": "properties.timeZone", "type": "str"}, + "advanced_schedule": {"key": "properties.advancedSchedule", "type": "AdvancedSchedule"}, } def __init__( @@ -6461,25 +6344,25 @@ def __init__( **kwargs ): """ - :keyword name: Required. Gets or sets the name of the Schedule. + :keyword name: Gets or sets the name of the Schedule. Required. :paramtype name: str :keyword description: Gets or sets the description of the schedule. :paramtype description: str - :keyword start_time: Required. Gets or sets the start time of the schedule. + :keyword start_time: Gets or sets the start time of the schedule. Required. :paramtype start_time: ~datetime.datetime :keyword expiry_time: Gets or sets the end time of the schedule. :paramtype expiry_time: ~datetime.datetime :keyword interval: Gets or sets the interval of the schedule. :paramtype interval: any - :keyword frequency: Required. Gets or sets the frequency of the schedule. Known values are: - "OneTime", "Day", "Hour", "Week", "Month", "Minute". + :keyword frequency: Gets or sets the frequency of the schedule. Required. Known values are: + "OneTime", "Day", "Hour", "Week", "Month", and "Minute". :paramtype frequency: str or ~azure.mgmt.automation.models.ScheduleFrequency :keyword time_zone: Gets or sets the time zone of the schedule. :paramtype time_zone: str :keyword advanced_schedule: Gets or sets the AdvancedSchedule. :paramtype advanced_schedule: ~azure.mgmt.automation.models.AdvancedSchedule """ - super(ScheduleCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.description = description self.start_time = start_time @@ -6490,7 +6373,7 @@ def __init__( self.advanced_schedule = advanced_schedule -class ScheduleListResult(msrest.serialization.Model): +class ScheduleListResult(_serialization.Model): """The response model for the list schedule operation. :ivar value: Gets or sets a list of schedules. @@ -6500,29 +6383,23 @@ class ScheduleListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Schedule]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Schedule]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.Schedule"]] = None, - next_link: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Schedule"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: Gets or sets a list of schedules. :paramtype value: list[~azure.mgmt.automation.models.Schedule] :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(ScheduleListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class ScheduleUpdateParameters(msrest.serialization.Model): +class ScheduleUpdateParameters(_serialization.Model): """The parameters supplied to the update schedule operation. :ivar name: Gets or sets the name of the Schedule. @@ -6534,9 +6411,9 @@ class ScheduleUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'is_enabled': {'key': 'properties.isEnabled', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, + "is_enabled": {"key": "properties.isEnabled", "type": "bool"}, } def __init__( @@ -6555,18 +6432,18 @@ def __init__( :keyword is_enabled: Gets or sets a value indicating whether this schedule is enabled. :paramtype is_enabled: bool """ - super(ScheduleUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.description = description self.is_enabled = is_enabled -class Sku(msrest.serialization.Model): +class Sku(_serialization.Model): """The account SKU. All required parameters must be populated in order to send to Azure. - :ivar name: Required. Gets or sets the SKU name of the account. Known values are: "Free", + :ivar name: Gets or sets the SKU name of the account. Required. Known values are: "Free" and "Basic". :vartype name: str or ~azure.mgmt.automation.models.SkuNameEnum :ivar family: Gets or sets the SKU family. @@ -6576,13 +6453,13 @@ class Sku(msrest.serialization.Model): """ _validation = { - 'name': {'required': True}, + "name": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'family': {'key': 'family', 'type': 'str'}, - 'capacity': {'key': 'capacity', 'type': 'int'}, + "name": {"key": "name", "type": "str"}, + "family": {"key": "family", "type": "str"}, + "capacity": {"key": "capacity", "type": "int"}, } def __init__( @@ -6594,7 +6471,7 @@ def __init__( **kwargs ): """ - :keyword name: Required. Gets or sets the SKU name of the account. Known values are: "Free", + :keyword name: Gets or sets the SKU name of the account. Required. Known values are: "Free" and "Basic". :paramtype name: str or ~azure.mgmt.automation.models.SkuNameEnum :keyword family: Gets or sets the SKU family. @@ -6602,13 +6479,13 @@ def __init__( :keyword capacity: Gets or sets the SKU capacity. :paramtype capacity: int """ - super(Sku, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.family = family self.capacity = capacity -class SoftwareUpdateConfiguration(msrest.serialization.Model): +class SoftwareUpdateConfiguration(_serialization.Model): # pylint: disable=too-many-instance-attributes """Software update configuration properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -6621,10 +6498,10 @@ class SoftwareUpdateConfiguration(msrest.serialization.Model): :vartype id: str :ivar type: Resource type. :vartype type: str - :ivar update_configuration: Required. update specific properties for the Software update - configuration. + :ivar update_configuration: update specific properties for the Software update configuration. + Required. :vartype update_configuration: ~azure.mgmt.automation.models.UpdateConfiguration - :ivar schedule_info: Required. Schedule information for the Software update configuration. + :ivar schedule_info: Schedule information for the Software update configuration. Required. :vartype schedule_info: ~azure.mgmt.automation.models.SUCScheduleProperties :ivar provisioning_state: Provisioning state for the software update configuration, which only appears in the response. @@ -6644,31 +6521,31 @@ class SoftwareUpdateConfiguration(msrest.serialization.Model): """ _validation = { - 'name': {'readonly': True}, - 'id': {'readonly': True}, - 'type': {'readonly': True}, - 'update_configuration': {'required': True}, - 'schedule_info': {'required': True}, - 'provisioning_state': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'created_by': {'readonly': True}, - 'last_modified_time': {'readonly': True}, - 'last_modified_by': {'readonly': True}, - } - - _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'id': {'key': 'id', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'update_configuration': {'key': 'properties.updateConfiguration', 'type': 'UpdateConfiguration'}, - 'schedule_info': {'key': 'properties.scheduleInfo', 'type': 'SUCScheduleProperties'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'error': {'key': 'properties.error', 'type': 'ErrorResponse'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'created_by': {'key': 'properties.createdBy', 'type': 'str'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'last_modified_by': {'key': 'properties.lastModifiedBy', 'type': 'str'}, - 'tasks': {'key': 'properties.tasks', 'type': 'SoftwareUpdateConfigurationTasks'}, + "name": {"readonly": True}, + "id": {"readonly": True}, + "type": {"readonly": True}, + "update_configuration": {"required": True}, + "schedule_info": {"required": True}, + "provisioning_state": {"readonly": True}, + "creation_time": {"readonly": True}, + "created_by": {"readonly": True}, + "last_modified_time": {"readonly": True}, + "last_modified_by": {"readonly": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "id": {"key": "id", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "update_configuration": {"key": "properties.updateConfiguration", "type": "UpdateConfiguration"}, + "schedule_info": {"key": "properties.scheduleInfo", "type": "SUCScheduleProperties"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "error": {"key": "properties.error", "type": "ErrorResponse"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "created_by": {"key": "properties.createdBy", "type": "str"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "last_modified_by": {"key": "properties.lastModifiedBy", "type": "str"}, + "tasks": {"key": "properties.tasks", "type": "SoftwareUpdateConfigurationTasks"}, } def __init__( @@ -6681,17 +6558,17 @@ def __init__( **kwargs ): """ - :keyword update_configuration: Required. update specific properties for the Software update - configuration. + :keyword update_configuration: update specific properties for the Software update + configuration. Required. :paramtype update_configuration: ~azure.mgmt.automation.models.UpdateConfiguration - :keyword schedule_info: Required. Schedule information for the Software update configuration. + :keyword schedule_info: Schedule information for the Software update configuration. Required. :paramtype schedule_info: ~azure.mgmt.automation.models.SUCScheduleProperties :keyword error: Details of provisioning error. :paramtype error: ~azure.mgmt.automation.models.ErrorResponse :keyword tasks: Tasks information for the Software update configuration. :paramtype tasks: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationTasks """ - super(SoftwareUpdateConfiguration, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = None self.id = None self.type = None @@ -6706,7 +6583,7 @@ def __init__( self.tasks = tasks -class SoftwareUpdateConfigurationCollectionItem(msrest.serialization.Model): +class SoftwareUpdateConfigurationCollectionItem(_serialization.Model): """Software update configuration collection item properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -6720,7 +6597,7 @@ class SoftwareUpdateConfigurationCollectionItem(msrest.serialization.Model): :ivar tasks: Pre and Post Tasks defined. :vartype tasks: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationTasks :ivar frequency: execution frequency of the schedule associated with the software update - configuration. Known values are: "OneTime", "Day", "Hour", "Week", "Month", "Minute". + configuration. Known values are: "OneTime", "Day", "Hour", "Week", "Month", and "Minute". :vartype frequency: str or ~azure.mgmt.automation.models.ScheduleFrequency :ivar start_time: the start time of the update. :vartype start_time: ~datetime.datetime @@ -6738,24 +6615,24 @@ class SoftwareUpdateConfigurationCollectionItem(msrest.serialization.Model): """ _validation = { - 'name': {'readonly': True}, - 'id': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'last_modified_time': {'readonly': True}, - 'provisioning_state': {'readonly': True}, + "name": {"readonly": True}, + "id": {"readonly": True}, + "creation_time": {"readonly": True}, + "last_modified_time": {"readonly": True}, + "provisioning_state": {"readonly": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'id': {'key': 'id', 'type': 'str'}, - 'update_configuration': {'key': 'properties.updateConfiguration', 'type': 'UpdateConfiguration'}, - 'tasks': {'key': 'properties.tasks', 'type': 'SoftwareUpdateConfigurationTasks'}, - 'frequency': {'key': 'properties.frequency', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'next_run': {'key': 'properties.nextRun', 'type': 'iso-8601'}, + "name": {"key": "name", "type": "str"}, + "id": {"key": "id", "type": "str"}, + "update_configuration": {"key": "properties.updateConfiguration", "type": "UpdateConfiguration"}, + "tasks": {"key": "properties.tasks", "type": "SoftwareUpdateConfigurationTasks"}, + "frequency": {"key": "properties.frequency", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "next_run": {"key": "properties.nextRun", "type": "iso-8601"}, } def __init__( @@ -6774,14 +6651,14 @@ def __init__( :keyword tasks: Pre and Post Tasks defined. :paramtype tasks: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationTasks :keyword frequency: execution frequency of the schedule associated with the software update - configuration. Known values are: "OneTime", "Day", "Hour", "Week", "Month", "Minute". + configuration. Known values are: "OneTime", "Day", "Hour", "Week", "Month", and "Minute". :paramtype frequency: str or ~azure.mgmt.automation.models.ScheduleFrequency :keyword start_time: the start time of the update. :paramtype start_time: ~datetime.datetime :keyword next_run: ext run time of the update. :paramtype next_run: ~datetime.datetime """ - super(SoftwareUpdateConfigurationCollectionItem, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = None self.id = None self.update_configuration = update_configuration @@ -6794,7 +6671,7 @@ def __init__( self.next_run = next_run -class SoftwareUpdateConfigurationListResult(msrest.serialization.Model): +class SoftwareUpdateConfigurationListResult(_serialization.Model): """result of listing all software update configuration. :ivar value: outer object returned when listing all software update configurations. @@ -6802,24 +6679,19 @@ class SoftwareUpdateConfigurationListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[SoftwareUpdateConfigurationCollectionItem]'}, + "value": {"key": "value", "type": "[SoftwareUpdateConfigurationCollectionItem]"}, } - def __init__( - self, - *, - value: Optional[List["_models.SoftwareUpdateConfigurationCollectionItem"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.SoftwareUpdateConfigurationCollectionItem"]] = None, **kwargs): """ :keyword value: outer object returned when listing all software update configurations. :paramtype value: list[~azure.mgmt.automation.models.SoftwareUpdateConfigurationCollectionItem] """ - super(SoftwareUpdateConfigurationListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class SoftwareUpdateConfigurationMachineRun(msrest.serialization.Model): +class SoftwareUpdateConfigurationMachineRun(_serialization.Model): # pylint: disable=too-many-instance-attributes """Software update configuration machine run model. Variables are only populated by the server, and will be ignored when sending a request. @@ -6864,42 +6736,45 @@ class SoftwareUpdateConfigurationMachineRun(msrest.serialization.Model): """ _validation = { - 'name': {'readonly': True}, - 'id': {'readonly': True}, - 'target_computer': {'readonly': True}, - 'target_computer_type': {'readonly': True}, - 'status': {'readonly': True}, - 'os_type': {'readonly': True}, - 'correlation_id': {'readonly': True}, - 'source_computer_id': {'readonly': True}, - 'start_time': {'readonly': True}, - 'end_time': {'readonly': True}, - 'configured_duration': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'created_by': {'readonly': True}, - 'last_modified_time': {'readonly': True}, - 'last_modified_by': {'readonly': True}, - } - - _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'id': {'key': 'id', 'type': 'str'}, - 'target_computer': {'key': 'properties.targetComputer', 'type': 'str'}, - 'target_computer_type': {'key': 'properties.targetComputerType', 'type': 'str'}, - 'software_update_configuration': {'key': 'properties.softwareUpdateConfiguration', 'type': 'UpdateConfigurationNavigation'}, - 'status': {'key': 'properties.status', 'type': 'str'}, - 'os_type': {'key': 'properties.osType', 'type': 'str'}, - 'correlation_id': {'key': 'properties.correlationId', 'type': 'str'}, - 'source_computer_id': {'key': 'properties.sourceComputerId', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'properties.endTime', 'type': 'iso-8601'}, - 'configured_duration': {'key': 'properties.configuredDuration', 'type': 'str'}, - 'job': {'key': 'properties.job', 'type': 'JobNavigation'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'created_by': {'key': 'properties.createdBy', 'type': 'str'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'last_modified_by': {'key': 'properties.lastModifiedBy', 'type': 'str'}, - 'error': {'key': 'properties.error', 'type': 'ErrorResponse'}, + "name": {"readonly": True}, + "id": {"readonly": True}, + "target_computer": {"readonly": True}, + "target_computer_type": {"readonly": True}, + "status": {"readonly": True}, + "os_type": {"readonly": True}, + "correlation_id": {"readonly": True}, + "source_computer_id": {"readonly": True}, + "start_time": {"readonly": True}, + "end_time": {"readonly": True}, + "configured_duration": {"readonly": True}, + "creation_time": {"readonly": True}, + "created_by": {"readonly": True}, + "last_modified_time": {"readonly": True}, + "last_modified_by": {"readonly": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "id": {"key": "id", "type": "str"}, + "target_computer": {"key": "properties.targetComputer", "type": "str"}, + "target_computer_type": {"key": "properties.targetComputerType", "type": "str"}, + "software_update_configuration": { + "key": "properties.softwareUpdateConfiguration", + "type": "UpdateConfigurationNavigation", + }, + "status": {"key": "properties.status", "type": "str"}, + "os_type": {"key": "properties.osType", "type": "str"}, + "correlation_id": {"key": "properties.correlationId", "type": "str"}, + "source_computer_id": {"key": "properties.sourceComputerId", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "end_time": {"key": "properties.endTime", "type": "iso-8601"}, + "configured_duration": {"key": "properties.configuredDuration", "type": "str"}, + "job": {"key": "properties.job", "type": "JobNavigation"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "created_by": {"key": "properties.createdBy", "type": "str"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "last_modified_by": {"key": "properties.lastModifiedBy", "type": "str"}, + "error": {"key": "properties.error", "type": "ErrorResponse"}, } def __init__( @@ -6919,7 +6794,7 @@ def __init__( :keyword error: Details of provisioning error. :paramtype error: ~azure.mgmt.automation.models.ErrorResponse """ - super(SoftwareUpdateConfigurationMachineRun, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = None self.id = None self.target_computer = None @@ -6940,7 +6815,7 @@ def __init__( self.error = error -class SoftwareUpdateConfigurationMachineRunListResult(msrest.serialization.Model): +class SoftwareUpdateConfigurationMachineRunListResult(_serialization.Model): """result of listing all software update configuration machine runs. :ivar value: outer object returned when listing all software update configuration machine runs. @@ -6950,8 +6825,8 @@ class SoftwareUpdateConfigurationMachineRunListResult(msrest.serialization.Model """ _attribute_map = { - 'value': {'key': 'value', 'type': '[SoftwareUpdateConfigurationMachineRun]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[SoftwareUpdateConfigurationMachineRun]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -6968,12 +6843,12 @@ def __init__( :keyword next_link: link to next page of results. :paramtype next_link: str """ - super(SoftwareUpdateConfigurationMachineRunListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class SoftwareUpdateConfigurationRun(msrest.serialization.Model): +class SoftwareUpdateConfigurationRun(_serialization.Model): # pylint: disable=too-many-instance-attributes """Software update configuration Run properties. Variables are only populated by the server, and will be ignored when sending a request. @@ -7012,37 +6887,40 @@ class SoftwareUpdateConfigurationRun(msrest.serialization.Model): """ _validation = { - 'name': {'readonly': True}, - 'id': {'readonly': True}, - 'status': {'readonly': True}, - 'configured_duration': {'readonly': True}, - 'os_type': {'readonly': True}, - 'start_time': {'readonly': True}, - 'end_time': {'readonly': True}, - 'computer_count': {'readonly': True}, - 'failed_count': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'created_by': {'readonly': True}, - 'last_modified_time': {'readonly': True}, - 'last_modified_by': {'readonly': True}, - } - - _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'id': {'key': 'id', 'type': 'str'}, - 'software_update_configuration': {'key': 'properties.softwareUpdateConfiguration', 'type': 'UpdateConfigurationNavigation'}, - 'status': {'key': 'properties.status', 'type': 'str'}, - 'configured_duration': {'key': 'properties.configuredDuration', 'type': 'str'}, - 'os_type': {'key': 'properties.osType', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'properties.endTime', 'type': 'iso-8601'}, - 'computer_count': {'key': 'properties.computerCount', 'type': 'int'}, - 'failed_count': {'key': 'properties.failedCount', 'type': 'int'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'created_by': {'key': 'properties.createdBy', 'type': 'str'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'last_modified_by': {'key': 'properties.lastModifiedBy', 'type': 'str'}, - 'tasks': {'key': 'properties.tasks', 'type': 'SoftwareUpdateConfigurationRunTasks'}, + "name": {"readonly": True}, + "id": {"readonly": True}, + "status": {"readonly": True}, + "configured_duration": {"readonly": True}, + "os_type": {"readonly": True}, + "start_time": {"readonly": True}, + "end_time": {"readonly": True}, + "computer_count": {"readonly": True}, + "failed_count": {"readonly": True}, + "creation_time": {"readonly": True}, + "created_by": {"readonly": True}, + "last_modified_time": {"readonly": True}, + "last_modified_by": {"readonly": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "id": {"key": "id", "type": "str"}, + "software_update_configuration": { + "key": "properties.softwareUpdateConfiguration", + "type": "UpdateConfigurationNavigation", + }, + "status": {"key": "properties.status", "type": "str"}, + "configured_duration": {"key": "properties.configuredDuration", "type": "str"}, + "os_type": {"key": "properties.osType", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "end_time": {"key": "properties.endTime", "type": "iso-8601"}, + "computer_count": {"key": "properties.computerCount", "type": "int"}, + "failed_count": {"key": "properties.failedCount", "type": "int"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "created_by": {"key": "properties.createdBy", "type": "str"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "last_modified_by": {"key": "properties.lastModifiedBy", "type": "str"}, + "tasks": {"key": "properties.tasks", "type": "SoftwareUpdateConfigurationRunTasks"}, } def __init__( @@ -7059,7 +6937,7 @@ def __init__( :keyword tasks: Software update configuration tasks triggered in this run. :paramtype tasks: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationRunTasks """ - super(SoftwareUpdateConfigurationRun, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = None self.id = None self.software_update_configuration = software_update_configuration @@ -7077,7 +6955,7 @@ def __init__( self.tasks = tasks -class SoftwareUpdateConfigurationRunListResult(msrest.serialization.Model): +class SoftwareUpdateConfigurationRunListResult(_serialization.Model): """result of listing all software update configuration runs. :ivar value: outer object returned when listing all software update configuration runs. @@ -7087,8 +6965,8 @@ class SoftwareUpdateConfigurationRunListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[SoftwareUpdateConfigurationRun]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[SoftwareUpdateConfigurationRun]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( @@ -7104,12 +6982,12 @@ def __init__( :keyword next_link: link to next page of results. :paramtype next_link: str """ - super(SoftwareUpdateConfigurationRunListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class SoftwareUpdateConfigurationRunTaskProperties(msrest.serialization.Model): +class SoftwareUpdateConfigurationRunTaskProperties(_serialization.Model): """Task properties of the software update configuration. :ivar status: The status of the task. @@ -7121,18 +6999,13 @@ class SoftwareUpdateConfigurationRunTaskProperties(msrest.serialization.Model): """ _attribute_map = { - 'status': {'key': 'status', 'type': 'str'}, - 'source': {'key': 'source', 'type': 'str'}, - 'job_id': {'key': 'jobId', 'type': 'str'}, + "status": {"key": "status", "type": "str"}, + "source": {"key": "source", "type": "str"}, + "job_id": {"key": "jobId", "type": "str"}, } def __init__( - self, - *, - status: Optional[str] = None, - source: Optional[str] = None, - job_id: Optional[str] = None, - **kwargs + self, *, status: Optional[str] = None, source: Optional[str] = None, job_id: Optional[str] = None, **kwargs ): """ :keyword status: The status of the task. @@ -7142,13 +7015,13 @@ def __init__( :keyword job_id: The job id of the task. :paramtype job_id: str """ - super(SoftwareUpdateConfigurationRunTaskProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.source = source self.job_id = job_id -class SoftwareUpdateConfigurationRunTasks(msrest.serialization.Model): +class SoftwareUpdateConfigurationRunTasks(_serialization.Model): """Software update configuration run tasks model. :ivar pre_task: Pre task properties. @@ -7158,8 +7031,8 @@ class SoftwareUpdateConfigurationRunTasks(msrest.serialization.Model): """ _attribute_map = { - 'pre_task': {'key': 'preTask', 'type': 'SoftwareUpdateConfigurationRunTaskProperties'}, - 'post_task': {'key': 'postTask', 'type': 'SoftwareUpdateConfigurationRunTaskProperties'}, + "pre_task": {"key": "preTask", "type": "SoftwareUpdateConfigurationRunTaskProperties"}, + "post_task": {"key": "postTask", "type": "SoftwareUpdateConfigurationRunTaskProperties"}, } def __init__( @@ -7176,12 +7049,12 @@ def __init__( :paramtype post_task: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationRunTaskProperties """ - super(SoftwareUpdateConfigurationRunTasks, self).__init__(**kwargs) + super().__init__(**kwargs) self.pre_task = pre_task self.post_task = post_task -class SoftwareUpdateConfigurationTasks(msrest.serialization.Model): +class SoftwareUpdateConfigurationTasks(_serialization.Model): """Task properties of the software update configuration. :ivar pre_task: Pre task properties. @@ -7191,8 +7064,8 @@ class SoftwareUpdateConfigurationTasks(msrest.serialization.Model): """ _attribute_map = { - 'pre_task': {'key': 'preTask', 'type': 'TaskProperties'}, - 'post_task': {'key': 'postTask', 'type': 'TaskProperties'}, + "pre_task": {"key": "preTask", "type": "TaskProperties"}, + "post_task": {"key": "postTask", "type": "TaskProperties"}, } def __init__( @@ -7208,12 +7081,12 @@ def __init__( :keyword post_task: Post task properties. :paramtype post_task: ~azure.mgmt.automation.models.TaskProperties """ - super(SoftwareUpdateConfigurationTasks, self).__init__(**kwargs) + super().__init__(**kwargs) self.pre_task = pre_task self.post_task = post_task -class SourceControl(ProxyResource): +class SourceControl(ProxyResource): # pylint: disable=too-many-instance-attributes """Definition of the source control. Variables are only populated by the server, and will be ignored when sending a request. @@ -7236,7 +7109,7 @@ class SourceControl(ProxyResource): :ivar publish_runbook: The auto publish of the source control. Default is true. :vartype publish_runbook: bool :ivar source_type: The source type. Must be one of VsoGit, VsoTfvc, GitHub. Known values are: - "VsoGit", "VsoTfvc", "GitHub". + "VsoGit", "VsoTfvc", and "GitHub". :vartype source_type: str or ~azure.mgmt.automation.models.SourceType :ivar description: The description. :vartype description: str @@ -7247,24 +7120,24 @@ class SourceControl(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'repo_url': {'key': 'properties.repoUrl', 'type': 'str'}, - 'branch': {'key': 'properties.branch', 'type': 'str'}, - 'folder_path': {'key': 'properties.folderPath', 'type': 'str'}, - 'auto_sync': {'key': 'properties.autoSync', 'type': 'bool'}, - 'publish_runbook': {'key': 'properties.publishRunbook', 'type': 'bool'}, - 'source_type': {'key': 'properties.sourceType', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "repo_url": {"key": "properties.repoUrl", "type": "str"}, + "branch": {"key": "properties.branch", "type": "str"}, + "folder_path": {"key": "properties.folderPath", "type": "str"}, + "auto_sync": {"key": "properties.autoSync", "type": "bool"}, + "publish_runbook": {"key": "properties.publishRunbook", "type": "bool"}, + "source_type": {"key": "properties.sourceType", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, } def __init__( @@ -7294,7 +7167,7 @@ def __init__( :keyword publish_runbook: The auto publish of the source control. Default is true. :paramtype publish_runbook: bool :keyword source_type: The source type. Must be one of VsoGit, VsoTfvc, GitHub. Known values - are: "VsoGit", "VsoTfvc", "GitHub". + are: "VsoGit", "VsoTfvc", and "GitHub". :paramtype source_type: str or ~azure.mgmt.automation.models.SourceType :keyword description: The description. :paramtype description: str @@ -7303,7 +7176,7 @@ def __init__( :keyword last_modified_time: The last modified time. :paramtype last_modified_time: ~datetime.datetime """ - super(SourceControl, self).__init__(**kwargs) + super().__init__(**kwargs) self.repo_url = repo_url self.branch = branch self.folder_path = folder_path @@ -7315,7 +7188,7 @@ def __init__( self.last_modified_time = last_modified_time -class SourceControlCreateOrUpdateParameters(msrest.serialization.Model): +class SourceControlCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update source control operation. :ivar repo_url: The repo url of the source control. @@ -7330,7 +7203,7 @@ class SourceControlCreateOrUpdateParameters(msrest.serialization.Model): :ivar publish_runbook: The auto publish of the source control. Default is true. :vartype publish_runbook: bool :ivar source_type: The source type. Must be one of VsoGit, VsoTfvc, GitHub, case sensitive. - Known values are: "VsoGit", "VsoTfvc", "GitHub". + Known values are: "VsoGit", "VsoTfvc", and "GitHub". :vartype source_type: str or ~azure.mgmt.automation.models.SourceType :ivar security_token: The authorization token for the repo of the source control. :vartype security_token: ~azure.mgmt.automation.models.SourceControlSecurityTokenProperties @@ -7339,21 +7212,21 @@ class SourceControlCreateOrUpdateParameters(msrest.serialization.Model): """ _validation = { - 'repo_url': {'max_length': 2000, 'min_length': 0}, - 'branch': {'max_length': 255, 'min_length': 0}, - 'folder_path': {'max_length': 255, 'min_length': 0}, - 'description': {'max_length': 512, 'min_length': 0}, + "repo_url": {"max_length": 2000}, + "branch": {"max_length": 255}, + "folder_path": {"max_length": 255}, + "description": {"max_length": 512}, } _attribute_map = { - 'repo_url': {'key': 'properties.repoUrl', 'type': 'str'}, - 'branch': {'key': 'properties.branch', 'type': 'str'}, - 'folder_path': {'key': 'properties.folderPath', 'type': 'str'}, - 'auto_sync': {'key': 'properties.autoSync', 'type': 'bool'}, - 'publish_runbook': {'key': 'properties.publishRunbook', 'type': 'bool'}, - 'source_type': {'key': 'properties.sourceType', 'type': 'str'}, - 'security_token': {'key': 'properties.securityToken', 'type': 'SourceControlSecurityTokenProperties'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "repo_url": {"key": "properties.repoUrl", "type": "str"}, + "branch": {"key": "properties.branch", "type": "str"}, + "folder_path": {"key": "properties.folderPath", "type": "str"}, + "auto_sync": {"key": "properties.autoSync", "type": "bool"}, + "publish_runbook": {"key": "properties.publishRunbook", "type": "bool"}, + "source_type": {"key": "properties.sourceType", "type": "str"}, + "security_token": {"key": "properties.securityToken", "type": "SourceControlSecurityTokenProperties"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -7382,14 +7255,14 @@ def __init__( :keyword publish_runbook: The auto publish of the source control. Default is true. :paramtype publish_runbook: bool :keyword source_type: The source type. Must be one of VsoGit, VsoTfvc, GitHub, case sensitive. - Known values are: "VsoGit", "VsoTfvc", "GitHub". + Known values are: "VsoGit", "VsoTfvc", and "GitHub". :paramtype source_type: str or ~azure.mgmt.automation.models.SourceType :keyword security_token: The authorization token for the repo of the source control. :paramtype security_token: ~azure.mgmt.automation.models.SourceControlSecurityTokenProperties :keyword description: The user description of the source control. :paramtype description: str """ - super(SourceControlCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.repo_url = repo_url self.branch = branch self.folder_path = folder_path @@ -7400,7 +7273,7 @@ def __init__( self.description = description -class SourceControlListResult(msrest.serialization.Model): +class SourceControlListResult(_serialization.Model): """The response model for the list source controls operation. :ivar value: The list of source controls. @@ -7410,16 +7283,12 @@ class SourceControlListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[SourceControl]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[SourceControl]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.SourceControl"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.SourceControl"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of source controls. @@ -7427,12 +7296,12 @@ def __init__( :keyword next_link: The next link. :paramtype next_link: str """ - super(SourceControlListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class SourceControlSecurityTokenProperties(msrest.serialization.Model): +class SourceControlSecurityTokenProperties(_serialization.Model): """SourceControlSecurityTokenProperties. :ivar access_token: The access token. @@ -7440,19 +7309,19 @@ class SourceControlSecurityTokenProperties(msrest.serialization.Model): :ivar refresh_token: The refresh token. :vartype refresh_token: str :ivar token_type: The token type. Must be either PersonalAccessToken or Oauth. Known values - are: "PersonalAccessToken", "Oauth". + are: "PersonalAccessToken" and "Oauth". :vartype token_type: str or ~azure.mgmt.automation.models.TokenType """ _validation = { - 'access_token': {'max_length': 1024, 'min_length': 0}, - 'refresh_token': {'max_length': 1024, 'min_length': 0}, + "access_token": {"max_length": 1024}, + "refresh_token": {"max_length": 1024}, } _attribute_map = { - 'access_token': {'key': 'accessToken', 'type': 'str'}, - 'refresh_token': {'key': 'refreshToken', 'type': 'str'}, - 'token_type': {'key': 'tokenType', 'type': 'str'}, + "access_token": {"key": "accessToken", "type": "str"}, + "refresh_token": {"key": "refreshToken", "type": "str"}, + "token_type": {"key": "tokenType", "type": "str"}, } def __init__( @@ -7469,16 +7338,16 @@ def __init__( :keyword refresh_token: The refresh token. :paramtype refresh_token: str :keyword token_type: The token type. Must be either PersonalAccessToken or Oauth. Known values - are: "PersonalAccessToken", "Oauth". + are: "PersonalAccessToken" and "Oauth". :paramtype token_type: str or ~azure.mgmt.automation.models.TokenType """ - super(SourceControlSecurityTokenProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.access_token = access_token self.refresh_token = refresh_token self.token_type = token_type -class SourceControlSyncJob(msrest.serialization.Model): +class SourceControlSyncJob(_serialization.Model): """Definition of the source control sync job. Variables are only populated by the server, and will be ignored when sending a request. @@ -7494,35 +7363,35 @@ class SourceControlSyncJob(msrest.serialization.Model): :ivar creation_time: The creation time of the job. :vartype creation_time: ~datetime.datetime :ivar provisioning_state: The provisioning state of the job. Known values are: "Completed", - "Failed", "Running". + "Failed", and "Running". :vartype provisioning_state: str or ~azure.mgmt.automation.models.ProvisioningState :ivar start_time: The start time of the job. :vartype start_time: ~datetime.datetime :ivar end_time: The end time of the job. :vartype end_time: ~datetime.datetime - :ivar sync_type: The sync type. Known values are: "PartialSync", "FullSync". + :ivar sync_type: The sync type. Known values are: "PartialSync" and "FullSync". :vartype sync_type: str or ~azure.mgmt.automation.models.SyncType """ _validation = { - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'id': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'start_time': {'readonly': True}, - 'end_time': {'readonly': True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "id": {"readonly": True}, + "creation_time": {"readonly": True}, + "start_time": {"readonly": True}, + "end_time": {"readonly": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'id': {'key': 'id', 'type': 'str'}, - 'source_control_sync_job_id': {'key': 'properties.sourceControlSyncJobId', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'properties.endTime', 'type': 'iso-8601'}, - 'sync_type': {'key': 'properties.syncType', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "id": {"key": "id", "type": "str"}, + "source_control_sync_job_id": {"key": "properties.sourceControlSyncJobId", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "end_time": {"key": "properties.endTime", "type": "iso-8601"}, + "sync_type": {"key": "properties.syncType", "type": "str"}, } def __init__( @@ -7537,12 +7406,12 @@ def __init__( :keyword source_control_sync_job_id: The source control sync job id. :paramtype source_control_sync_job_id: str :keyword provisioning_state: The provisioning state of the job. Known values are: "Completed", - "Failed", "Running". + "Failed", and "Running". :paramtype provisioning_state: str or ~azure.mgmt.automation.models.ProvisioningState - :keyword sync_type: The sync type. Known values are: "PartialSync", "FullSync". + :keyword sync_type: The sync type. Known values are: "PartialSync" and "FullSync". :paramtype sync_type: str or ~azure.mgmt.automation.models.SyncType """ - super(SourceControlSyncJob, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = None self.type = None self.id = None @@ -7554,7 +7423,7 @@ def __init__( self.sync_type = sync_type -class SourceControlSyncJobById(msrest.serialization.Model): +class SourceControlSyncJobById(_serialization.Model): """Definition of the source control sync job. Variables are only populated by the server, and will be ignored when sending a request. @@ -7566,39 +7435,39 @@ class SourceControlSyncJobById(msrest.serialization.Model): :ivar creation_time: The creation time of the job. :vartype creation_time: ~datetime.datetime :ivar provisioning_state: The provisioning state of the job. Known values are: "Completed", - "Failed", "Running". + "Failed", and "Running". :vartype provisioning_state: str or ~azure.mgmt.automation.models.ProvisioningState :ivar start_time: The start time of the job. :vartype start_time: ~datetime.datetime :ivar end_time: The end time of the job. :vartype end_time: ~datetime.datetime - :ivar sync_type: The sync type. Known values are: "PartialSync", "FullSync". + :ivar sync_type: The sync type. Known values are: "PartialSync" and "FullSync". :vartype sync_type: str or ~azure.mgmt.automation.models.SyncType :ivar exception: The exceptions that occurred while running the sync job. :vartype exception: str """ _validation = { - 'creation_time': {'readonly': True}, - 'start_time': {'readonly': True}, - 'end_time': {'readonly': True}, + "creation_time": {"readonly": True}, + "start_time": {"readonly": True}, + "end_time": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'source_control_sync_job_id': {'key': 'properties.sourceControlSyncJobId', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, - 'start_time': {'key': 'properties.startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'properties.endTime', 'type': 'iso-8601'}, - 'sync_type': {'key': 'properties.syncType', 'type': 'str'}, - 'exception': {'key': 'properties.exception', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "source_control_sync_job_id": {"key": "properties.sourceControlSyncJobId", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "provisioning_state": {"key": "properties.provisioningState", "type": "str"}, + "start_time": {"key": "properties.startTime", "type": "iso-8601"}, + "end_time": {"key": "properties.endTime", "type": "iso-8601"}, + "sync_type": {"key": "properties.syncType", "type": "str"}, + "exception": {"key": "properties.exception", "type": "str"}, } def __init__( self, *, - id: Optional[str] = None, + id: Optional[str] = None, # pylint: disable=redefined-builtin source_control_sync_job_id: Optional[str] = None, provisioning_state: Optional[Union[str, "_models.ProvisioningState"]] = None, sync_type: Optional[Union[str, "_models.SyncType"]] = None, @@ -7611,14 +7480,14 @@ def __init__( :keyword source_control_sync_job_id: The source control sync job id. :paramtype source_control_sync_job_id: str :keyword provisioning_state: The provisioning state of the job. Known values are: "Completed", - "Failed", "Running". + "Failed", and "Running". :paramtype provisioning_state: str or ~azure.mgmt.automation.models.ProvisioningState - :keyword sync_type: The sync type. Known values are: "PartialSync", "FullSync". + :keyword sync_type: The sync type. Known values are: "PartialSync" and "FullSync". :paramtype sync_type: str or ~azure.mgmt.automation.models.SyncType :keyword exception: The exceptions that occurred while running the sync job. :paramtype exception: str """ - super(SourceControlSyncJobById, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.source_control_sync_job_id = source_control_sync_job_id self.creation_time = None @@ -7629,40 +7498,35 @@ def __init__( self.exception = exception -class SourceControlSyncJobCreateParameters(msrest.serialization.Model): +class SourceControlSyncJobCreateParameters(_serialization.Model): """The parameters supplied to the create source control sync job operation. All required parameters must be populated in order to send to Azure. - :ivar commit_id: Required. The commit id of the source control sync job. If not syncing to a - commitId, enter an empty string. + :ivar commit_id: The commit id of the source control sync job. If not syncing to a commitId, + enter an empty string. Required. :vartype commit_id: str """ _validation = { - 'commit_id': {'required': True}, + "commit_id": {"required": True}, } _attribute_map = { - 'commit_id': {'key': 'properties.commitId', 'type': 'str'}, + "commit_id": {"key": "properties.commitId", "type": "str"}, } - def __init__( - self, - *, - commit_id: str, - **kwargs - ): + def __init__(self, *, commit_id: str, **kwargs): """ - :keyword commit_id: Required. The commit id of the source control sync job. If not syncing to a - commitId, enter an empty string. + :keyword commit_id: The commit id of the source control sync job. If not syncing to a commitId, + enter an empty string. Required. :paramtype commit_id: str """ - super(SourceControlSyncJobCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.commit_id = commit_id -class SourceControlSyncJobListResult(msrest.serialization.Model): +class SourceControlSyncJobListResult(_serialization.Model): """The response model for the list source control sync jobs operation. :ivar value: The list of source control sync jobs. @@ -7672,16 +7536,12 @@ class SourceControlSyncJobListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[SourceControlSyncJob]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[SourceControlSyncJob]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - value: Optional[List["_models.SourceControlSyncJob"]] = None, - next_link: Optional[str] = None, - **kwargs + self, *, value: Optional[List["_models.SourceControlSyncJob"]] = None, next_link: Optional[str] = None, **kwargs ): """ :keyword value: The list of source control sync jobs. @@ -7689,12 +7549,12 @@ def __init__( :keyword next_link: The next link. :paramtype next_link: str """ - super(SourceControlSyncJobListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class SourceControlSyncJobStream(msrest.serialization.Model): +class SourceControlSyncJobStream(_serialization.Model): """Definition of the source control sync job stream. Variables are only populated by the server, and will be ignored when sending a request. @@ -7707,21 +7567,21 @@ class SourceControlSyncJobStream(msrest.serialization.Model): :vartype summary: str :ivar time: The time of the sync job stream. :vartype time: ~datetime.datetime - :ivar stream_type: The type of the sync job stream. Known values are: "Error", "Output". + :ivar stream_type: The type of the sync job stream. Known values are: "Error" and "Output". :vartype stream_type: str or ~azure.mgmt.automation.models.StreamType """ _validation = { - 'id': {'readonly': True}, - 'time': {'readonly': True}, + "id": {"readonly": True}, + "time": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'source_control_sync_job_stream_id': {'key': 'properties.sourceControlSyncJobStreamId', 'type': 'str'}, - 'summary': {'key': 'properties.summary', 'type': 'str'}, - 'time': {'key': 'properties.time', 'type': 'iso-8601'}, - 'stream_type': {'key': 'properties.streamType', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "source_control_sync_job_stream_id": {"key": "properties.sourceControlSyncJobStreamId", "type": "str"}, + "summary": {"key": "properties.summary", "type": "str"}, + "time": {"key": "properties.time", "type": "iso-8601"}, + "stream_type": {"key": "properties.streamType", "type": "str"}, } def __init__( @@ -7737,10 +7597,10 @@ def __init__( :paramtype source_control_sync_job_stream_id: str :keyword summary: The summary of the sync job stream. :paramtype summary: str - :keyword stream_type: The type of the sync job stream. Known values are: "Error", "Output". + :keyword stream_type: The type of the sync job stream. Known values are: "Error" and "Output". :paramtype stream_type: str or ~azure.mgmt.automation.models.StreamType """ - super(SourceControlSyncJobStream, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.source_control_sync_job_stream_id = source_control_sync_job_stream_id self.summary = summary @@ -7748,7 +7608,7 @@ def __init__( self.stream_type = stream_type -class SourceControlSyncJobStreamById(msrest.serialization.Model): +class SourceControlSyncJobStreamById(_serialization.Model): """Definition of the source control sync job stream by id. Variables are only populated by the server, and will be ignored when sending a request. @@ -7761,27 +7621,27 @@ class SourceControlSyncJobStreamById(msrest.serialization.Model): :vartype summary: str :ivar time: The time of the sync job stream. :vartype time: ~datetime.datetime - :ivar stream_type: The type of the sync job stream. Known values are: "Error", "Output". + :ivar stream_type: The type of the sync job stream. Known values are: "Error" and "Output". :vartype stream_type: str or ~azure.mgmt.automation.models.StreamType :ivar stream_text: The text of the sync job stream. :vartype stream_text: str :ivar value: The values of the job stream. - :vartype value: dict[str, any] + :vartype value: dict[str, JSON] """ _validation = { - 'id': {'readonly': True}, - 'time': {'readonly': True}, + "id": {"readonly": True}, + "time": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'source_control_sync_job_stream_id': {'key': 'properties.sourceControlSyncJobStreamId', 'type': 'str'}, - 'summary': {'key': 'properties.summary', 'type': 'str'}, - 'time': {'key': 'properties.time', 'type': 'iso-8601'}, - 'stream_type': {'key': 'properties.streamType', 'type': 'str'}, - 'stream_text': {'key': 'properties.streamText', 'type': 'str'}, - 'value': {'key': 'properties.value', 'type': '{object}'}, + "id": {"key": "id", "type": "str"}, + "source_control_sync_job_stream_id": {"key": "properties.sourceControlSyncJobStreamId", "type": "str"}, + "summary": {"key": "properties.summary", "type": "str"}, + "time": {"key": "properties.time", "type": "iso-8601"}, + "stream_type": {"key": "properties.streamType", "type": "str"}, + "stream_text": {"key": "properties.streamText", "type": "str"}, + "value": {"key": "properties.value", "type": "{object}"}, } def __init__( @@ -7791,7 +7651,7 @@ def __init__( summary: Optional[str] = None, stream_type: Optional[Union[str, "_models.StreamType"]] = None, stream_text: Optional[str] = None, - value: Optional[Dict[str, Any]] = None, + value: Optional[Dict[str, JSON]] = None, **kwargs ): """ @@ -7799,14 +7659,14 @@ def __init__( :paramtype source_control_sync_job_stream_id: str :keyword summary: The summary of the sync job stream. :paramtype summary: str - :keyword stream_type: The type of the sync job stream. Known values are: "Error", "Output". + :keyword stream_type: The type of the sync job stream. Known values are: "Error" and "Output". :paramtype stream_type: str or ~azure.mgmt.automation.models.StreamType :keyword stream_text: The text of the sync job stream. :paramtype stream_text: str :keyword value: The values of the job stream. - :paramtype value: dict[str, any] + :paramtype value: dict[str, JSON] """ - super(SourceControlSyncJobStreamById, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = None self.source_control_sync_job_stream_id = source_control_sync_job_stream_id self.summary = summary @@ -7816,7 +7676,7 @@ def __init__( self.value = value -class SourceControlSyncJobStreamsListBySyncJob(msrest.serialization.Model): +class SourceControlSyncJobStreamsListBySyncJob(_serialization.Model): """The response model for the list source control sync job streams operation. Variables are only populated by the server, and will be ignored when sending a request. @@ -7828,30 +7688,25 @@ class SourceControlSyncJobStreamsListBySyncJob(msrest.serialization.Model): """ _validation = { - 'next_link': {'readonly': True}, + "next_link": {"readonly": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': '[SourceControlSyncJobStream]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[SourceControlSyncJobStream]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.SourceControlSyncJobStream"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.SourceControlSyncJobStream"]] = None, **kwargs): """ :keyword value: The list of source control sync job streams. :paramtype value: list[~azure.mgmt.automation.models.SourceControlSyncJobStream] """ - super(SourceControlSyncJobStreamsListBySyncJob, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = None -class SourceControlUpdateParameters(msrest.serialization.Model): +class SourceControlUpdateParameters(_serialization.Model): """The parameters supplied to the update source control operation. :ivar branch: The repo branch of the source control. @@ -7869,12 +7724,12 @@ class SourceControlUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'branch': {'key': 'properties.branch', 'type': 'str'}, - 'folder_path': {'key': 'properties.folderPath', 'type': 'str'}, - 'auto_sync': {'key': 'properties.autoSync', 'type': 'bool'}, - 'publish_runbook': {'key': 'properties.publishRunbook', 'type': 'bool'}, - 'security_token': {'key': 'properties.securityToken', 'type': 'SourceControlSecurityTokenProperties'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "branch": {"key": "properties.branch", "type": "str"}, + "folder_path": {"key": "properties.folderPath", "type": "str"}, + "auto_sync": {"key": "properties.autoSync", "type": "bool"}, + "publish_runbook": {"key": "properties.publishRunbook", "type": "bool"}, + "security_token": {"key": "properties.securityToken", "type": "SourceControlSecurityTokenProperties"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -7902,7 +7757,7 @@ def __init__( :keyword description: The user description of the source control. :paramtype description: str """ - super(SourceControlUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.branch = branch self.folder_path = folder_path self.auto_sync = auto_sync @@ -7911,7 +7766,7 @@ def __init__( self.description = description -class Statistics(msrest.serialization.Model): +class Statistics(_serialization.Model): """Definition of the statistic. Variables are only populated by the server, and will be ignored when sending a request. @@ -7919,7 +7774,7 @@ class Statistics(msrest.serialization.Model): :ivar counter_property: Gets the property value of the statistic. :vartype counter_property: str :ivar counter_value: Gets the value of the statistic. - :vartype counter_value: long + :vartype counter_value: int :ivar start_time: Gets the startTime of the statistic. :vartype start_time: ~datetime.datetime :ivar end_time: Gets the endTime of the statistic. @@ -7929,28 +7784,24 @@ class Statistics(msrest.serialization.Model): """ _validation = { - 'counter_property': {'readonly': True}, - 'counter_value': {'readonly': True}, - 'start_time': {'readonly': True}, - 'end_time': {'readonly': True}, - 'id': {'readonly': True}, + "counter_property": {"readonly": True}, + "counter_value": {"readonly": True}, + "start_time": {"readonly": True}, + "end_time": {"readonly": True}, + "id": {"readonly": True}, } _attribute_map = { - 'counter_property': {'key': 'counterProperty', 'type': 'str'}, - 'counter_value': {'key': 'counterValue', 'type': 'long'}, - 'start_time': {'key': 'startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'endTime', 'type': 'iso-8601'}, - 'id': {'key': 'id', 'type': 'str'}, + "counter_property": {"key": "counterProperty", "type": "str"}, + "counter_value": {"key": "counterValue", "type": "int"}, + "start_time": {"key": "startTime", "type": "iso-8601"}, + "end_time": {"key": "endTime", "type": "iso-8601"}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(Statistics, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.counter_property = None self.counter_value = None self.start_time = None @@ -7958,7 +7809,7 @@ def __init__( self.id = None -class StatisticsListResult(msrest.serialization.Model): +class StatisticsListResult(_serialization.Model): """The response model for the list statistics operation. :ivar value: Gets or sets a list of statistics. @@ -7966,24 +7817,19 @@ class StatisticsListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Statistics]'}, + "value": {"key": "value", "type": "[Statistics]"}, } - def __init__( - self, - *, - value: Optional[List["_models.Statistics"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Statistics"]] = None, **kwargs): """ :keyword value: Gets or sets a list of statistics. :paramtype value: list[~azure.mgmt.automation.models.Statistics] """ - super(StatisticsListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class SUCScheduleProperties(msrest.serialization.Model): +class SUCScheduleProperties(_serialization.Model): # pylint: disable=too-many-instance-attributes """Definition of schedule parameters. Variables are only populated by the server, and will be ignored when sending a request. @@ -8003,9 +7849,9 @@ class SUCScheduleProperties(msrest.serialization.Model): :ivar next_run_offset_minutes: Gets or sets the next run time's offset in minutes. :vartype next_run_offset_minutes: float :ivar interval: Gets or sets the interval of the schedule. - :vartype interval: long + :vartype interval: int :ivar frequency: Gets or sets the frequency of the schedule. Known values are: "OneTime", - "Day", "Hour", "Week", "Month", "Minute". + "Day", "Hour", "Week", "Month", and "Minute". :vartype frequency: str or ~azure.mgmt.automation.models.ScheduleFrequency :ivar time_zone: Gets or sets the time zone of the schedule. :vartype time_zone: str @@ -8020,24 +7866,24 @@ class SUCScheduleProperties(msrest.serialization.Model): """ _validation = { - 'start_time_offset_minutes': {'readonly': True}, + "start_time_offset_minutes": {"readonly": True}, } _attribute_map = { - 'start_time': {'key': 'startTime', 'type': 'iso-8601'}, - 'start_time_offset_minutes': {'key': 'startTimeOffsetMinutes', 'type': 'float'}, - 'expiry_time': {'key': 'expiryTime', 'type': 'iso-8601'}, - 'expiry_time_offset_minutes': {'key': 'expiryTimeOffsetMinutes', 'type': 'float'}, - 'is_enabled': {'key': 'isEnabled', 'type': 'bool'}, - 'next_run': {'key': 'nextRun', 'type': 'iso-8601'}, - 'next_run_offset_minutes': {'key': 'nextRunOffsetMinutes', 'type': 'float'}, - 'interval': {'key': 'interval', 'type': 'long'}, - 'frequency': {'key': 'frequency', 'type': 'str'}, - 'time_zone': {'key': 'timeZone', 'type': 'str'}, - 'advanced_schedule': {'key': 'advancedSchedule', 'type': 'AdvancedSchedule'}, - 'creation_time': {'key': 'creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'description', 'type': 'str'}, + "start_time": {"key": "startTime", "type": "iso-8601"}, + "start_time_offset_minutes": {"key": "startTimeOffsetMinutes", "type": "float"}, + "expiry_time": {"key": "expiryTime", "type": "iso-8601"}, + "expiry_time_offset_minutes": {"key": "expiryTimeOffsetMinutes", "type": "float"}, + "is_enabled": {"key": "isEnabled", "type": "bool"}, + "next_run": {"key": "nextRun", "type": "iso-8601"}, + "next_run_offset_minutes": {"key": "nextRunOffsetMinutes", "type": "float"}, + "interval": {"key": "interval", "type": "int"}, + "frequency": {"key": "frequency", "type": "str"}, + "time_zone": {"key": "timeZone", "type": "str"}, + "advanced_schedule": {"key": "advancedSchedule", "type": "AdvancedSchedule"}, + "creation_time": {"key": "creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "description", "type": "str"}, } def __init__( @@ -8046,7 +7892,7 @@ def __init__( start_time: Optional[datetime.datetime] = None, expiry_time: Optional[datetime.datetime] = None, expiry_time_offset_minutes: Optional[float] = None, - is_enabled: Optional[bool] = False, + is_enabled: bool = False, next_run: Optional[datetime.datetime] = None, next_run_offset_minutes: Optional[float] = None, interval: Optional[int] = None, @@ -8072,9 +7918,9 @@ def __init__( :keyword next_run_offset_minutes: Gets or sets the next run time's offset in minutes. :paramtype next_run_offset_minutes: float :keyword interval: Gets or sets the interval of the schedule. - :paramtype interval: long + :paramtype interval: int :keyword frequency: Gets or sets the frequency of the schedule. Known values are: "OneTime", - "Day", "Hour", "Week", "Month", "Minute". + "Day", "Hour", "Week", "Month", and "Minute". :paramtype frequency: str or ~azure.mgmt.automation.models.ScheduleFrequency :keyword time_zone: Gets or sets the time zone of the schedule. :paramtype time_zone: str @@ -8087,7 +7933,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(SUCScheduleProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.start_time = start_time self.start_time_offset_minutes = None self.expiry_time = expiry_time @@ -8104,32 +7950,32 @@ def __init__( self.description = description -class SystemData(msrest.serialization.Model): +class SystemData(_serialization.Model): """Metadata pertaining to creation and last modification of the resource. :ivar created_by: The identity that created the resource. :vartype created_by: str :ivar created_by_type: The type of identity that created the resource. Known values are: - "User", "Application", "ManagedIdentity", "Key". + "User", "Application", "ManagedIdentity", and "Key". :vartype created_by_type: str or ~azure.mgmt.automation.models.CreatedByType :ivar created_at: The timestamp of resource creation (UTC). :vartype created_at: ~datetime.datetime :ivar last_modified_by: The identity that last modified the resource. :vartype last_modified_by: str :ivar last_modified_by_type: The type of identity that last modified the resource. Known values - are: "User", "Application", "ManagedIdentity", "Key". + are: "User", "Application", "ManagedIdentity", and "Key". :vartype last_modified_by_type: str or ~azure.mgmt.automation.models.CreatedByType :ivar last_modified_at: The timestamp of resource last modification (UTC). :vartype last_modified_at: ~datetime.datetime """ _attribute_map = { - 'created_by': {'key': 'createdBy', 'type': 'str'}, - 'created_by_type': {'key': 'createdByType', 'type': 'str'}, - 'created_at': {'key': 'createdAt', 'type': 'iso-8601'}, - 'last_modified_by': {'key': 'lastModifiedBy', 'type': 'str'}, - 'last_modified_by_type': {'key': 'lastModifiedByType', 'type': 'str'}, - 'last_modified_at': {'key': 'lastModifiedAt', 'type': 'iso-8601'}, + "created_by": {"key": "createdBy", "type": "str"}, + "created_by_type": {"key": "createdByType", "type": "str"}, + "created_at": {"key": "createdAt", "type": "iso-8601"}, + "last_modified_by": {"key": "lastModifiedBy", "type": "str"}, + "last_modified_by_type": {"key": "lastModifiedByType", "type": "str"}, + "last_modified_at": {"key": "lastModifiedAt", "type": "iso-8601"}, } def __init__( @@ -8147,19 +7993,19 @@ def __init__( :keyword created_by: The identity that created the resource. :paramtype created_by: str :keyword created_by_type: The type of identity that created the resource. Known values are: - "User", "Application", "ManagedIdentity", "Key". + "User", "Application", "ManagedIdentity", and "Key". :paramtype created_by_type: str or ~azure.mgmt.automation.models.CreatedByType :keyword created_at: The timestamp of resource creation (UTC). :paramtype created_at: ~datetime.datetime :keyword last_modified_by: The identity that last modified the resource. :paramtype last_modified_by: str :keyword last_modified_by_type: The type of identity that last modified the resource. Known - values are: "User", "Application", "ManagedIdentity", "Key". + values are: "User", "Application", "ManagedIdentity", and "Key". :paramtype last_modified_by_type: str or ~azure.mgmt.automation.models.CreatedByType :keyword last_modified_at: The timestamp of resource last modification (UTC). :paramtype last_modified_at: ~datetime.datetime """ - super(SystemData, self).__init__(**kwargs) + super().__init__(**kwargs) self.created_by = created_by self.created_by_type = created_by_type self.created_at = created_at @@ -8168,18 +8014,19 @@ def __init__( self.last_modified_at = last_modified_at -class TagSettingsProperties(msrest.serialization.Model): +class TagSettingsProperties(_serialization.Model): """Tag filter information for the VM. - :ivar tags: A set of tags. Dictionary of tags with its list of values. + :ivar tags: Dictionary of tags with its list of values. :vartype tags: dict[str, list[str]] - :ivar filter_operator: Filter VMs by Any or All specified tags. Known values are: "All", "Any". + :ivar filter_operator: Filter VMs by Any or All specified tags. Known values are: "All" and + "Any". :vartype filter_operator: str or ~azure.mgmt.automation.models.TagOperators """ _attribute_map = { - 'tags': {'key': 'tags', 'type': '{[str]}'}, - 'filter_operator': {'key': 'filterOperator', 'type': 'str'}, + "tags": {"key": "tags", "type": "{[str]}"}, + "filter_operator": {"key": "filterOperator", "type": "str"}, } def __init__( @@ -8190,18 +8037,18 @@ def __init__( **kwargs ): """ - :keyword tags: A set of tags. Dictionary of tags with its list of values. + :keyword tags: Dictionary of tags with its list of values. :paramtype tags: dict[str, list[str]] - :keyword filter_operator: Filter VMs by Any or All specified tags. Known values are: "All", + :keyword filter_operator: Filter VMs by Any or All specified tags. Known values are: "All" and "Any". :paramtype filter_operator: str or ~azure.mgmt.automation.models.TagOperators """ - super(TagSettingsProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.tags = tags self.filter_operator = filter_operator -class TargetProperties(msrest.serialization.Model): +class TargetProperties(_serialization.Model): """Group specific to the update configuration. :ivar azure_queries: List of Azure queries in the software update configuration. @@ -8211,8 +8058,8 @@ class TargetProperties(msrest.serialization.Model): """ _attribute_map = { - 'azure_queries': {'key': 'azureQueries', 'type': '[AzureQueryProperties]'}, - 'non_azure_queries': {'key': 'nonAzureQueries', 'type': '[NonAzureQueryProperties]'}, + "azure_queries": {"key": "azureQueries", "type": "[AzureQueryProperties]"}, + "non_azure_queries": {"key": "nonAzureQueries", "type": "[NonAzureQueryProperties]"}, } def __init__( @@ -8228,12 +8075,12 @@ def __init__( :keyword non_azure_queries: List of non Azure queries in the software update configuration. :paramtype non_azure_queries: list[~azure.mgmt.automation.models.NonAzureQueryProperties] """ - super(TargetProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.azure_queries = azure_queries self.non_azure_queries = non_azure_queries -class TaskProperties(msrest.serialization.Model): +class TaskProperties(_serialization.Model): """Task properties of the software update configuration. :ivar parameters: Gets or sets the parameters of the task. @@ -8243,29 +8090,23 @@ class TaskProperties(msrest.serialization.Model): """ _attribute_map = { - 'parameters': {'key': 'parameters', 'type': '{str}'}, - 'source': {'key': 'source', 'type': 'str'}, + "parameters": {"key": "parameters", "type": "{str}"}, + "source": {"key": "source", "type": "str"}, } - def __init__( - self, - *, - parameters: Optional[Dict[str, str]] = None, - source: Optional[str] = None, - **kwargs - ): + def __init__(self, *, parameters: Optional[Dict[str, str]] = None, source: Optional[str] = None, **kwargs): """ :keyword parameters: Gets or sets the parameters of the task. :paramtype parameters: dict[str, str] :keyword source: Gets or sets the name of the runbook. :paramtype source: str """ - super(TaskProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.parameters = parameters self.source = source -class TestJob(msrest.serialization.Model): +class TestJob(_serialization.Model): # pylint: disable=too-many-instance-attributes """Definition of the test job. :ivar creation_time: Gets or sets the creation time of the test job. @@ -8294,17 +8135,17 @@ class TestJob(msrest.serialization.Model): """ _attribute_map = { - 'creation_time': {'key': 'creationTime', 'type': 'iso-8601'}, - 'status': {'key': 'status', 'type': 'str'}, - 'status_details': {'key': 'statusDetails', 'type': 'str'}, - 'run_on': {'key': 'runOn', 'type': 'str'}, - 'start_time': {'key': 'startTime', 'type': 'iso-8601'}, - 'end_time': {'key': 'endTime', 'type': 'iso-8601'}, - 'exception': {'key': 'exception', 'type': 'str'}, - 'last_modified_time': {'key': 'lastModifiedTime', 'type': 'iso-8601'}, - 'last_status_modified_time': {'key': 'lastStatusModifiedTime', 'type': 'iso-8601'}, - 'parameters': {'key': 'parameters', 'type': '{str}'}, - 'log_activity_trace': {'key': 'logActivityTrace', 'type': 'int'}, + "creation_time": {"key": "creationTime", "type": "iso-8601"}, + "status": {"key": "status", "type": "str"}, + "status_details": {"key": "statusDetails", "type": "str"}, + "run_on": {"key": "runOn", "type": "str"}, + "start_time": {"key": "startTime", "type": "iso-8601"}, + "end_time": {"key": "endTime", "type": "iso-8601"}, + "exception": {"key": "exception", "type": "str"}, + "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"}, + "last_status_modified_time": {"key": "lastStatusModifiedTime", "type": "iso-8601"}, + "parameters": {"key": "parameters", "type": "{str}"}, + "log_activity_trace": {"key": "logActivityTrace", "type": "int"}, } def __init__( @@ -8348,7 +8189,7 @@ def __init__( :keyword log_activity_trace: The activity-level tracing options of the runbook. :paramtype log_activity_trace: int """ - super(TestJob, self).__init__(**kwargs) + super().__init__(**kwargs) self.creation_time = creation_time self.status = status self.status_details = status_details @@ -8362,7 +8203,7 @@ def __init__( self.log_activity_trace = log_activity_trace -class TestJobCreateParameters(msrest.serialization.Model): +class TestJobCreateParameters(_serialization.Model): """The parameters supplied to the create test job operation. :ivar parameters: Gets or sets the parameters of the test job. @@ -8373,17 +8214,11 @@ class TestJobCreateParameters(msrest.serialization.Model): """ _attribute_map = { - 'parameters': {'key': 'parameters', 'type': '{str}'}, - 'run_on': {'key': 'runOn', 'type': 'str'}, + "parameters": {"key": "parameters", "type": "{str}"}, + "run_on": {"key": "runOn", "type": "str"}, } - def __init__( - self, - *, - parameters: Optional[Dict[str, str]] = None, - run_on: Optional[str] = None, - **kwargs - ): + def __init__(self, *, parameters: Optional[Dict[str, str]] = None, run_on: Optional[str] = None, **kwargs): """ :keyword parameters: Gets or sets the parameters of the test job. :paramtype parameters: dict[str, str] @@ -8391,12 +8226,12 @@ def __init__( executed. :paramtype run_on: str """ - super(TestJobCreateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.parameters = parameters self.run_on = run_on -class TypeField(msrest.serialization.Model): +class TypeField(_serialization.Model): """Information about a field of a type. :ivar name: Gets or sets the name of the field. @@ -8406,29 +8241,23 @@ class TypeField(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, } - def __init__( - self, - *, - name: Optional[str] = None, - type: Optional[str] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, type: Optional[str] = None, **kwargs): """ :keyword name: Gets or sets the name of the field. :paramtype name: str :keyword type: Gets or sets the type of the field. :paramtype type: str """ - super(TypeField, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.type = type -class TypeFieldListResult(msrest.serialization.Model): +class TypeFieldListResult(_serialization.Model): """The response model for the list fields operation. :ivar value: Gets or sets a list of fields. @@ -8436,30 +8265,25 @@ class TypeFieldListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[TypeField]'}, + "value": {"key": "value", "type": "[TypeField]"}, } - def __init__( - self, - *, - value: Optional[List["_models.TypeField"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.TypeField"]] = None, **kwargs): """ :keyword value: Gets or sets a list of fields. :paramtype value: list[~azure.mgmt.automation.models.TypeField] """ - super(TypeFieldListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value -class UpdateConfiguration(msrest.serialization.Model): +class UpdateConfiguration(_serialization.Model): """Update specific properties of the software update configuration. All required parameters must be populated in order to send to Azure. - :ivar operating_system: Required. operating system of target machines. Known values are: - "Windows", "Linux". + :ivar operating_system: operating system of target machines. Required. Known values are: + "Windows" and "Linux". :vartype operating_system: str or ~azure.mgmt.automation.models.OperatingSystemType :ivar windows: Windows specific update configuration. :vartype windows: ~azure.mgmt.automation.models.WindowsProperties @@ -8479,17 +8303,17 @@ class UpdateConfiguration(msrest.serialization.Model): """ _validation = { - 'operating_system': {'required': True}, + "operating_system": {"required": True}, } _attribute_map = { - 'operating_system': {'key': 'operatingSystem', 'type': 'str'}, - 'windows': {'key': 'windows', 'type': 'WindowsProperties'}, - 'linux': {'key': 'linux', 'type': 'LinuxProperties'}, - 'duration': {'key': 'duration', 'type': 'duration'}, - 'azure_virtual_machines': {'key': 'azureVirtualMachines', 'type': '[str]'}, - 'non_azure_computer_names': {'key': 'nonAzureComputerNames', 'type': '[str]'}, - 'targets': {'key': 'targets', 'type': 'TargetProperties'}, + "operating_system": {"key": "operatingSystem", "type": "str"}, + "windows": {"key": "windows", "type": "WindowsProperties"}, + "linux": {"key": "linux", "type": "LinuxProperties"}, + "duration": {"key": "duration", "type": "duration"}, + "azure_virtual_machines": {"key": "azureVirtualMachines", "type": "[str]"}, + "non_azure_computer_names": {"key": "nonAzureComputerNames", "type": "[str]"}, + "targets": {"key": "targets", "type": "TargetProperties"}, } def __init__( @@ -8505,8 +8329,8 @@ def __init__( **kwargs ): """ - :keyword operating_system: Required. operating system of target machines. Known values are: - "Windows", "Linux". + :keyword operating_system: operating system of target machines. Required. Known values are: + "Windows" and "Linux". :paramtype operating_system: str or ~azure.mgmt.automation.models.OperatingSystemType :keyword windows: Windows specific update configuration. :paramtype windows: ~azure.mgmt.automation.models.WindowsProperties @@ -8524,7 +8348,7 @@ def __init__( :keyword targets: Group targets for the software update configuration. :paramtype targets: ~azure.mgmt.automation.models.TargetProperties """ - super(UpdateConfiguration, self).__init__(**kwargs) + super().__init__(**kwargs) self.operating_system = operating_system self.windows = windows self.linux = linux @@ -8534,7 +8358,7 @@ def __init__( self.targets = targets -class UpdateConfigurationNavigation(msrest.serialization.Model): +class UpdateConfigurationNavigation(_serialization.Model): """Software update configuration Run Navigation model. Variables are only populated by the server, and will be ignored when sending a request. @@ -8545,24 +8369,20 @@ class UpdateConfigurationNavigation(msrest.serialization.Model): """ _validation = { - 'name': {'readonly': True}, + "name": {"readonly": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, } - def __init__( - self, - **kwargs - ): - """ - """ - super(UpdateConfigurationNavigation, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.name = None -class Usage(msrest.serialization.Model): +class Usage(_serialization.Model): """Definition of Usage. :ivar id: Gets or sets the id of the resource. @@ -8574,24 +8394,24 @@ class Usage(msrest.serialization.Model): :ivar current_value: Gets or sets the current usage value. :vartype current_value: float :ivar limit: Gets or sets max limit. -1 for unlimited. - :vartype limit: long + :vartype limit: int :ivar throttle_status: Gets or sets the throttle status. :vartype throttle_status: str """ _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'UsageCounterName'}, - 'unit': {'key': 'unit', 'type': 'str'}, - 'current_value': {'key': 'currentValue', 'type': 'float'}, - 'limit': {'key': 'limit', 'type': 'long'}, - 'throttle_status': {'key': 'throttleStatus', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "UsageCounterName"}, + "unit": {"key": "unit", "type": "str"}, + "current_value": {"key": "currentValue", "type": "float"}, + "limit": {"key": "limit", "type": "int"}, + "throttle_status": {"key": "throttleStatus", "type": "str"}, } def __init__( self, *, - id: Optional[str] = None, + id: Optional[str] = None, # pylint: disable=redefined-builtin name: Optional["_models.UsageCounterName"] = None, unit: Optional[str] = None, current_value: Optional[float] = None, @@ -8609,11 +8429,11 @@ def __init__( :keyword current_value: Gets or sets the current usage value. :paramtype current_value: float :keyword limit: Gets or sets max limit. -1 for unlimited. - :paramtype limit: long + :paramtype limit: int :keyword throttle_status: Gets or sets the throttle status. :paramtype throttle_status: str """ - super(Usage, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.name = name self.unit = unit @@ -8622,7 +8442,7 @@ def __init__( self.throttle_status = throttle_status -class UsageCounterName(msrest.serialization.Model): +class UsageCounterName(_serialization.Model): """Definition of usage counter name. :ivar value: Gets or sets the usage counter name. @@ -8632,29 +8452,23 @@ class UsageCounterName(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, - 'localized_value': {'key': 'localizedValue', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, + "localized_value": {"key": "localizedValue", "type": "str"}, } - def __init__( - self, - *, - value: Optional[str] = None, - localized_value: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[str] = None, localized_value: Optional[str] = None, **kwargs): """ :keyword value: Gets or sets the usage counter name. :paramtype value: str :keyword localized_value: Gets or sets the localized usage counter name. :paramtype localized_value: str """ - super(UsageCounterName, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.localized_value = localized_value -class UsageListResult(msrest.serialization.Model): +class UsageListResult(_serialization.Model): """The response model for the get usage operation. :ivar value: Gets or sets usage. @@ -8662,23 +8476,46 @@ class UsageListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Usage]'}, + "value": {"key": "value", "type": "[Usage]"}, } - def __init__( - self, - *, - value: Optional[List["_models.Usage"]] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Usage"]] = None, **kwargs): """ :keyword value: Gets or sets usage. :paramtype value: list[~azure.mgmt.automation.models.Usage] """ - super(UsageListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value +class UserAssignedIdentitiesProperties(_serialization.Model): + """UserAssignedIdentitiesProperties. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar principal_id: The principal id of user assigned identity. + :vartype principal_id: str + :ivar client_id: The client id of user assigned identity. + :vartype client_id: str + """ + + _validation = { + "principal_id": {"readonly": True}, + "client_id": {"readonly": True}, + } + + _attribute_map = { + "principal_id": {"key": "principalId", "type": "str"}, + "client_id": {"key": "clientId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) + self.principal_id = None + self.client_id = None + + class Variable(ProxyResource): """Definition of the variable. @@ -8703,20 +8540,20 @@ class Variable(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'value': {'key': 'properties.value', 'type': 'str'}, - 'is_encrypted': {'key': 'properties.isEncrypted', 'type': 'bool'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "value": {"key": "properties.value", "type": "str"}, + "is_encrypted": {"key": "properties.isEncrypted", "type": "bool"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -8741,7 +8578,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(Variable, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.is_encrypted = is_encrypted self.creation_time = creation_time @@ -8749,12 +8586,12 @@ def __init__( self.description = description -class VariableCreateOrUpdateParameters(msrest.serialization.Model): +class VariableCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update variable operation. All required parameters must be populated in order to send to Azure. - :ivar name: Required. Gets or sets the name of the variable. + :ivar name: Gets or sets the name of the variable. Required. :vartype name: str :ivar value: Gets or sets the value of the variable. :vartype value: str @@ -8765,14 +8602,14 @@ class VariableCreateOrUpdateParameters(msrest.serialization.Model): """ _validation = { - 'name': {'required': True}, + "name": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'value': {'key': 'properties.value', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, - 'is_encrypted': {'key': 'properties.isEncrypted', 'type': 'bool'}, + "name": {"key": "name", "type": "str"}, + "value": {"key": "properties.value", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, + "is_encrypted": {"key": "properties.isEncrypted", "type": "bool"}, } def __init__( @@ -8785,7 +8622,7 @@ def __init__( **kwargs ): """ - :keyword name: Required. Gets or sets the name of the variable. + :keyword name: Gets or sets the name of the variable. Required. :paramtype name: str :keyword value: Gets or sets the value of the variable. :paramtype value: str @@ -8794,14 +8631,14 @@ def __init__( :keyword is_encrypted: Gets or sets the encrypted flag of the variable. :paramtype is_encrypted: bool """ - super(VariableCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.value = value self.description = description self.is_encrypted = is_encrypted -class VariableListResult(msrest.serialization.Model): +class VariableListResult(_serialization.Model): """The response model for the list variables operation. :ivar value: Gets or sets a list of variables. @@ -8811,29 +8648,23 @@ class VariableListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Variable]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Variable]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.Variable"]] = None, - next_link: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Variable"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: Gets or sets a list of variables. :paramtype value: list[~azure.mgmt.automation.models.Variable] :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(VariableListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class VariableUpdateParameters(msrest.serialization.Model): +class VariableUpdateParameters(_serialization.Model): """The parameters supplied to the update variable operation. :ivar name: Gets or sets the name of the variable. @@ -8845,18 +8676,13 @@ class VariableUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'value': {'key': 'properties.value', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "value": {"key": "properties.value", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( - self, - *, - name: Optional[str] = None, - value: Optional[str] = None, - description: Optional[str] = None, - **kwargs + self, *, name: Optional[str] = None, value: Optional[str] = None, description: Optional[str] = None, **kwargs ): """ :keyword name: Gets or sets the name of the variable. @@ -8866,13 +8692,13 @@ def __init__( :keyword description: Gets or sets the description of the variable. :paramtype description: str """ - super(VariableUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.value = value self.description = description -class Watcher(Resource): +class Watcher(Resource): # pylint: disable=too-many-instance-attributes """Definition of the watcher type. Variables are only populated by the server, and will be ignored when sending a request. @@ -8885,13 +8711,13 @@ class Watcher(Resource): :vartype type: str :ivar etag: Gets or sets the etag of the resource. :vartype etag: str - :ivar tags: A set of tags. Resource tags. + :ivar tags: Resource tags. :vartype tags: dict[str, str] :ivar location: The geo-location where the resource lives. :vartype location: str :ivar execution_frequency_in_seconds: Gets or sets the frequency at which the watcher is invoked. - :vartype execution_frequency_in_seconds: long + :vartype execution_frequency_in_seconds: int :ivar script_name: Gets or sets the name of the script the watcher is attached to, i.e. the name of an existing runbook. :vartype script_name: str @@ -8912,31 +8738,31 @@ class Watcher(Resource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, - 'status': {'readonly': True}, - 'creation_time': {'readonly': True}, - 'last_modified_time': {'readonly': True}, - 'last_modified_by': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'etag': {'key': 'etag', 'type': 'str'}, - 'tags': {'key': 'tags', 'type': '{str}'}, - 'location': {'key': 'location', 'type': 'str'}, - 'execution_frequency_in_seconds': {'key': 'properties.executionFrequencyInSeconds', 'type': 'long'}, - 'script_name': {'key': 'properties.scriptName', 'type': 'str'}, - 'script_parameters': {'key': 'properties.scriptParameters', 'type': '{str}'}, - 'script_run_on': {'key': 'properties.scriptRunOn', 'type': 'str'}, - 'status': {'key': 'properties.status', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'last_modified_by': {'key': 'properties.lastModifiedBy', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "status": {"readonly": True}, + "creation_time": {"readonly": True}, + "last_modified_time": {"readonly": True}, + "last_modified_by": {"readonly": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "etag": {"key": "etag", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "location": {"key": "location", "type": "str"}, + "execution_frequency_in_seconds": {"key": "properties.executionFrequencyInSeconds", "type": "int"}, + "script_name": {"key": "properties.scriptName", "type": "str"}, + "script_parameters": {"key": "properties.scriptParameters", "type": "{str}"}, + "script_run_on": {"key": "properties.scriptRunOn", "type": "str"}, + "status": {"key": "properties.status", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "last_modified_by": {"key": "properties.lastModifiedBy", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -8955,13 +8781,13 @@ def __init__( """ :keyword etag: Gets or sets the etag of the resource. :paramtype etag: str - :keyword tags: A set of tags. Resource tags. + :keyword tags: Resource tags. :paramtype tags: dict[str, str] :keyword location: The geo-location where the resource lives. :paramtype location: str :keyword execution_frequency_in_seconds: Gets or sets the frequency at which the watcher is invoked. - :paramtype execution_frequency_in_seconds: long + :paramtype execution_frequency_in_seconds: int :keyword script_name: Gets or sets the name of the script the watcher is attached to, i.e. the name of an existing runbook. :paramtype script_name: str @@ -8973,7 +8799,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(Watcher, self).__init__(**kwargs) + super().__init__(**kwargs) self.etag = etag self.tags = tags self.location = location @@ -8988,7 +8814,7 @@ def __init__( self.description = description -class WatcherListResult(msrest.serialization.Model): +class WatcherListResult(_serialization.Model): """The response model for the list watcher operation. :ivar value: Gets or sets a list of watchers. @@ -8998,63 +8824,51 @@ class WatcherListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Watcher]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Watcher]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.Watcher"]] = None, - next_link: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Watcher"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: Gets or sets a list of watchers. :paramtype value: list[~azure.mgmt.automation.models.Watcher] :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(WatcherListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class WatcherUpdateParameters(msrest.serialization.Model): +class WatcherUpdateParameters(_serialization.Model): """WatcherUpdateParameters. :ivar name: Gets or sets the name of the resource. :vartype name: str :ivar execution_frequency_in_seconds: Gets or sets the frequency at which the watcher is invoked. - :vartype execution_frequency_in_seconds: long + :vartype execution_frequency_in_seconds: int """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'execution_frequency_in_seconds': {'key': 'properties.executionFrequencyInSeconds', 'type': 'long'}, + "name": {"key": "name", "type": "str"}, + "execution_frequency_in_seconds": {"key": "properties.executionFrequencyInSeconds", "type": "int"}, } - def __init__( - self, - *, - name: Optional[str] = None, - execution_frequency_in_seconds: Optional[int] = None, - **kwargs - ): + def __init__(self, *, name: Optional[str] = None, execution_frequency_in_seconds: Optional[int] = None, **kwargs): """ :keyword name: Gets or sets the name of the resource. :paramtype name: str :keyword execution_frequency_in_seconds: Gets or sets the frequency at which the watcher is invoked. - :paramtype execution_frequency_in_seconds: long + :paramtype execution_frequency_in_seconds: int """ - super(WatcherUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.execution_frequency_in_seconds = execution_frequency_in_seconds -class Webhook(ProxyResource): +class Webhook(ProxyResource): # pylint: disable=too-many-instance-attributes """Definition of the webhook type. Variables are only populated by the server, and will be ignored when sending a request. @@ -9091,32 +8905,32 @@ class Webhook(ProxyResource): """ _validation = { - 'id': {'readonly': True}, - 'name': {'readonly': True}, - 'type': {'readonly': True}, + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'name': {'key': 'name', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'is_enabled': {'key': 'properties.isEnabled', 'type': 'bool'}, - 'uri': {'key': 'properties.uri', 'type': 'str'}, - 'expiry_time': {'key': 'properties.expiryTime', 'type': 'iso-8601'}, - 'last_invoked_time': {'key': 'properties.lastInvokedTime', 'type': 'iso-8601'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, - 'runbook': {'key': 'properties.runbook', 'type': 'RunbookAssociationProperty'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, - 'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'}, - 'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'}, - 'last_modified_by': {'key': 'properties.lastModifiedBy', 'type': 'str'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "is_enabled": {"key": "properties.isEnabled", "type": "bool"}, + "uri": {"key": "properties.uri", "type": "str"}, + "expiry_time": {"key": "properties.expiryTime", "type": "iso-8601"}, + "last_invoked_time": {"key": "properties.lastInvokedTime", "type": "iso-8601"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, + "runbook": {"key": "properties.runbook", "type": "RunbookAssociationProperty"}, + "run_on": {"key": "properties.runOn", "type": "str"}, + "creation_time": {"key": "properties.creationTime", "type": "iso-8601"}, + "last_modified_time": {"key": "properties.lastModifiedTime", "type": "iso-8601"}, + "last_modified_by": {"key": "properties.lastModifiedBy", "type": "str"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( self, *, - is_enabled: Optional[bool] = False, + is_enabled: bool = False, uri: Optional[str] = None, expiry_time: Optional[datetime.datetime] = None, last_invoked_time: Optional[datetime.datetime] = None, @@ -9154,7 +8968,7 @@ def __init__( :keyword description: Gets or sets the description. :paramtype description: str """ - super(Webhook, self).__init__(**kwargs) + super().__init__(**kwargs) self.is_enabled = is_enabled self.uri = uri self.expiry_time = expiry_time @@ -9168,12 +8982,12 @@ def __init__( self.description = description -class WebhookCreateOrUpdateParameters(msrest.serialization.Model): +class WebhookCreateOrUpdateParameters(_serialization.Model): """The parameters supplied to the create or update webhook operation. All required parameters must be populated in order to send to Azure. - :ivar name: Required. Gets or sets the name of the webhook. + :ivar name: Gets or sets the name of the webhook. Required. :vartype name: str :ivar is_enabled: Gets or sets the value of the enabled flag of webhook. :vartype is_enabled: bool @@ -9190,17 +9004,17 @@ class WebhookCreateOrUpdateParameters(msrest.serialization.Model): """ _validation = { - 'name': {'required': True}, + "name": {"required": True}, } _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'is_enabled': {'key': 'properties.isEnabled', 'type': 'bool'}, - 'uri': {'key': 'properties.uri', 'type': 'str'}, - 'expiry_time': {'key': 'properties.expiryTime', 'type': 'iso-8601'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, - 'runbook': {'key': 'properties.runbook', 'type': 'RunbookAssociationProperty'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "is_enabled": {"key": "properties.isEnabled", "type": "bool"}, + "uri": {"key": "properties.uri", "type": "str"}, + "expiry_time": {"key": "properties.expiryTime", "type": "iso-8601"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, + "runbook": {"key": "properties.runbook", "type": "RunbookAssociationProperty"}, + "run_on": {"key": "properties.runOn", "type": "str"}, } def __init__( @@ -9216,7 +9030,7 @@ def __init__( **kwargs ): """ - :keyword name: Required. Gets or sets the name of the webhook. + :keyword name: Gets or sets the name of the webhook. Required. :paramtype name: str :keyword is_enabled: Gets or sets the value of the enabled flag of webhook. :paramtype is_enabled: bool @@ -9231,7 +9045,7 @@ def __init__( :keyword run_on: Gets or sets the name of the hybrid worker group the webhook job will run on. :paramtype run_on: str """ - super(WebhookCreateOrUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.is_enabled = is_enabled self.uri = uri @@ -9241,7 +9055,7 @@ def __init__( self.run_on = run_on -class WebhookListResult(msrest.serialization.Model): +class WebhookListResult(_serialization.Model): """The response model for the list webhook operation. :ivar value: Gets or sets a list of webhooks. @@ -9251,29 +9065,23 @@ class WebhookListResult(msrest.serialization.Model): """ _attribute_map = { - 'value': {'key': 'value', 'type': '[Webhook]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[Webhook]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: Optional[List["_models.Webhook"]] = None, - next_link: Optional[str] = None, - **kwargs - ): + def __init__(self, *, value: Optional[List["_models.Webhook"]] = None, next_link: Optional[str] = None, **kwargs): """ :keyword value: Gets or sets a list of webhooks. :paramtype value: list[~azure.mgmt.automation.models.Webhook] :keyword next_link: Gets or sets the next link. :paramtype next_link: str """ - super(WebhookListResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.value = value self.next_link = next_link -class WebhookUpdateParameters(msrest.serialization.Model): +class WebhookUpdateParameters(_serialization.Model): """The parameters supplied to the update webhook operation. :ivar name: Gets or sets the name of the webhook. @@ -9289,11 +9097,11 @@ class WebhookUpdateParameters(msrest.serialization.Model): """ _attribute_map = { - 'name': {'key': 'name', 'type': 'str'}, - 'is_enabled': {'key': 'properties.isEnabled', 'type': 'bool'}, - 'run_on': {'key': 'properties.runOn', 'type': 'str'}, - 'parameters': {'key': 'properties.parameters', 'type': '{str}'}, - 'description': {'key': 'properties.description', 'type': 'str'}, + "name": {"key": "name", "type": "str"}, + "is_enabled": {"key": "properties.isEnabled", "type": "bool"}, + "run_on": {"key": "properties.runOn", "type": "str"}, + "parameters": {"key": "properties.parameters", "type": "{str}"}, + "description": {"key": "properties.description", "type": "str"}, } def __init__( @@ -9318,7 +9126,7 @@ def __init__( :keyword description: Gets or sets the description of the webhook. :paramtype description: str """ - super(WebhookUpdateParameters, self).__init__(**kwargs) + super().__init__(**kwargs) self.name = name self.is_enabled = is_enabled self.run_on = run_on @@ -9326,13 +9134,13 @@ def __init__( self.description = description -class WindowsProperties(msrest.serialization.Model): +class WindowsProperties(_serialization.Model): """Windows specific update configuration. :ivar included_update_classifications: Update classification included in the software update configuration. A comma separated string with required values. Known values are: "Unclassified", "Critical", "Security", "UpdateRollup", "FeaturePack", "ServicePack", "Definition", "Tools", - "Updates". + and "Updates". :vartype included_update_classifications: str or ~azure.mgmt.automation.models.WindowsUpdateClasses :ivar excluded_kb_numbers: KB numbers excluded from the software update configuration. @@ -9344,10 +9152,10 @@ class WindowsProperties(msrest.serialization.Model): """ _attribute_map = { - 'included_update_classifications': {'key': 'includedUpdateClassifications', 'type': 'str'}, - 'excluded_kb_numbers': {'key': 'excludedKbNumbers', 'type': '[str]'}, - 'included_kb_numbers': {'key': 'includedKbNumbers', 'type': '[str]'}, - 'reboot_setting': {'key': 'rebootSetting', 'type': 'str'}, + "included_update_classifications": {"key": "includedUpdateClassifications", "type": "str"}, + "excluded_kb_numbers": {"key": "excludedKbNumbers", "type": "[str]"}, + "included_kb_numbers": {"key": "includedKbNumbers", "type": "[str]"}, + "reboot_setting": {"key": "rebootSetting", "type": "str"}, } def __init__( @@ -9363,7 +9171,7 @@ def __init__( :keyword included_update_classifications: Update classification included in the software update configuration. A comma separated string with required values. Known values are: "Unclassified", "Critical", "Security", "UpdateRollup", "FeaturePack", "ServicePack", "Definition", "Tools", - "Updates". + and "Updates". :paramtype included_update_classifications: str or ~azure.mgmt.automation.models.WindowsUpdateClasses :keyword excluded_kb_numbers: KB numbers excluded from the software update configuration. @@ -9373,7 +9181,7 @@ def __init__( :keyword reboot_setting: Reboot setting for the software update configuration. :paramtype reboot_setting: str """ - super(WindowsProperties, self).__init__(**kwargs) + super().__init__(**kwargs) self.included_update_classifications = included_update_classifications self.excluded_kb_numbers = excluded_kb_numbers self.included_kb_numbers = included_kb_numbers diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_patch.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_patch.py index 0ad201a8c586..f7dd32510333 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_patch.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/models/_patch.py @@ -10,6 +10,7 @@ __all__: List[str] = [] # Add all objects you want publicly available to users at this package level + def patch_sdk(): """Do not remove from this file. diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/__init__.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/__init__.py index e8ed3f355edf..930e68918be0 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/__init__.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/__init__.py @@ -8,17 +8,17 @@ from ._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations from ._private_link_resources_operations import PrivateLinkResourcesOperations -from ._python2_package_operations import Python2PackageOperations from ._agent_registration_information_operations import AgentRegistrationInformationOperations from ._dsc_node_operations import DscNodeOperations from ._node_reports_operations import NodeReportsOperations -from ._dsc_node_configuration_operations import DscNodeConfigurationOperations from ._dsc_compilation_job_operations import DscCompilationJobOperations from ._dsc_compilation_job_stream_operations import DscCompilationJobStreamOperations from ._node_count_information_operations import NodeCountInformationOperations -from ._source_control_operations import SourceControlOperations -from ._source_control_sync_job_operations import SourceControlSyncJobOperations -from ._source_control_sync_job_streams_operations import SourceControlSyncJobStreamsOperations +from ._watcher_operations import WatcherOperations +from ._software_update_configurations_operations import SoftwareUpdateConfigurationsOperations +from ._webhook_operations import WebhookOperations +from ._deleted_automation_accounts_operations import DeletedAutomationAccountsOperations +from ._python3_package_operations import Python3PackageOperations from ._automation_account_operations import AutomationAccountOperations from ._statistics_operations import StatisticsOperations from ._usages_operations import UsagesOperations @@ -27,80 +27,85 @@ from ._connection_operations import ConnectionOperations from ._connection_type_operations import ConnectionTypeOperations from ._credential_operations import CredentialOperations +from ._dsc_configuration_operations import DscConfigurationOperations +from ._dsc_node_configuration_operations import DscNodeConfigurationOperations +from ._hybrid_runbook_workers_operations import HybridRunbookWorkersOperations from ._hybrid_runbook_worker_group_operations import HybridRunbookWorkerGroupOperations +from ._job_operations import JobOperations +from ._job_stream_operations import JobStreamOperations from ._job_schedule_operations import JobScheduleOperations from ._linked_workspace_operations import LinkedWorkspaceOperations from ._activity_operations import ActivityOperations from ._module_operations import ModuleOperations from ._object_data_types_operations import ObjectDataTypesOperations from ._fields_operations import FieldsOperations -from ._schedule_operations import ScheduleOperations -from ._variable_operations import VariableOperations -from ._watcher_operations import WatcherOperations -from ._dsc_configuration_operations import DscConfigurationOperations -from ._job_operations import JobOperations -from ._job_stream_operations import JobStreamOperations from ._operations import Operations from ._automation_client_operations import AutomationClientOperationsMixin -from ._software_update_configurations_operations import SoftwareUpdateConfigurationsOperations -from ._software_update_configuration_runs_operations import SoftwareUpdateConfigurationRunsOperations -from ._software_update_configuration_machine_runs_operations import SoftwareUpdateConfigurationMachineRunsOperations +from ._python2_package_operations import Python2PackageOperations from ._runbook_draft_operations import RunbookDraftOperations from ._runbook_operations import RunbookOperations from ._test_job_streams_operations import TestJobStreamsOperations from ._test_job_operations import TestJobOperations -from ._webhook_operations import WebhookOperations -from ._hybrid_runbook_workers_operations import HybridRunbookWorkersOperations +from ._schedule_operations import ScheduleOperations +from ._software_update_configuration_machine_runs_operations import SoftwareUpdateConfigurationMachineRunsOperations +from ._software_update_configuration_runs_operations import SoftwareUpdateConfigurationRunsOperations +from ._source_control_operations import SourceControlOperations +from ._source_control_sync_job_operations import SourceControlSyncJobOperations +from ._source_control_sync_job_streams_operations import SourceControlSyncJobStreamsOperations +from ._variable_operations import VariableOperations from ._patch import __all__ as _patch_all from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'PrivateEndpointConnectionsOperations', - 'PrivateLinkResourcesOperations', - 'Python2PackageOperations', - 'AgentRegistrationInformationOperations', - 'DscNodeOperations', - 'NodeReportsOperations', - 'DscNodeConfigurationOperations', - 'DscCompilationJobOperations', - 'DscCompilationJobStreamOperations', - 'NodeCountInformationOperations', - 'SourceControlOperations', - 'SourceControlSyncJobOperations', - 'SourceControlSyncJobStreamsOperations', - 'AutomationAccountOperations', - 'StatisticsOperations', - 'UsagesOperations', - 'KeysOperations', - 'CertificateOperations', - 'ConnectionOperations', - 'ConnectionTypeOperations', - 'CredentialOperations', - 'HybridRunbookWorkerGroupOperations', - 'JobScheduleOperations', - 'LinkedWorkspaceOperations', - 'ActivityOperations', - 'ModuleOperations', - 'ObjectDataTypesOperations', - 'FieldsOperations', - 'ScheduleOperations', - 'VariableOperations', - 'WatcherOperations', - 'DscConfigurationOperations', - 'JobOperations', - 'JobStreamOperations', - 'Operations', - 'AutomationClientOperationsMixin', - 'SoftwareUpdateConfigurationsOperations', - 'SoftwareUpdateConfigurationRunsOperations', - 'SoftwareUpdateConfigurationMachineRunsOperations', - 'RunbookDraftOperations', - 'RunbookOperations', - 'TestJobStreamsOperations', - 'TestJobOperations', - 'WebhookOperations', - 'HybridRunbookWorkersOperations', + "PrivateEndpointConnectionsOperations", + "PrivateLinkResourcesOperations", + "AgentRegistrationInformationOperations", + "DscNodeOperations", + "NodeReportsOperations", + "DscCompilationJobOperations", + "DscCompilationJobStreamOperations", + "NodeCountInformationOperations", + "WatcherOperations", + "SoftwareUpdateConfigurationsOperations", + "WebhookOperations", + "DeletedAutomationAccountsOperations", + "Python3PackageOperations", + "AutomationAccountOperations", + "StatisticsOperations", + "UsagesOperations", + "KeysOperations", + "CertificateOperations", + "ConnectionOperations", + "ConnectionTypeOperations", + "CredentialOperations", + "DscConfigurationOperations", + "DscNodeConfigurationOperations", + "HybridRunbookWorkersOperations", + "HybridRunbookWorkerGroupOperations", + "JobOperations", + "JobStreamOperations", + "JobScheduleOperations", + "LinkedWorkspaceOperations", + "ActivityOperations", + "ModuleOperations", + "ObjectDataTypesOperations", + "FieldsOperations", + "Operations", + "AutomationClientOperationsMixin", + "Python2PackageOperations", + "RunbookDraftOperations", + "RunbookOperations", + "TestJobStreamsOperations", + "TestJobOperations", + "ScheduleOperations", + "SoftwareUpdateConfigurationMachineRunsOperations", + "SoftwareUpdateConfigurationRunsOperations", + "SourceControlOperations", + "SourceControlSyncJobOperations", + "SourceControlSyncJobStreamsOperations", + "VariableOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() \ No newline at end of file +_patch_sdk() diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_activity_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_activity_operations.py index 98601aaa74aa..991051b13eae 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_activity_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_activity_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +24,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_request( resource_group_name: str, automation_account_name: str, @@ -38,73 +45,68 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities/{activityName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities/{activityName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "moduleName": _SERIALIZER.url("module_name", module_name, 'str'), - "activityName": _SERIALIZER.url("activity_name", activity_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "moduleName": _SERIALIZER.url("module_name", module_name, "str"), + "activityName": _SERIALIZER.url("activity_name", activity_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_module_request( - resource_group_name: str, - automation_account_name: str, - module_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, module_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "moduleName": _SERIALIZER.url("module_name", module_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "moduleName": _SERIALIZER.url("module_name", module_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ActivityOperations: """ @@ -125,7 +127,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def get( self, @@ -137,34 +138,28 @@ def get( ) -> _models.Activity: """Retrieve the activity in the module identified by module name and activity name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param activity_name: The name of activity. + :param activity_name: The name of activity. Required. :type activity_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Activity, or the result of cls(response) + :return: Activity or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Activity - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Activity] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Activity] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -172,7 +167,7 @@ def get( activity_name=activity_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -180,10 +175,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -191,60 +185,51 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Activity', pipeline_response) + deserialized = self._deserialize("Activity", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities/{activityName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities/{activityName}"} # type: ignore @distributed_trace def list_by_module( - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - **kwargs: Any - ) -> Iterable[_models.ActivityListResult]: + self, resource_group_name: str, automation_account_name: str, module_name: str, **kwargs: Any + ) -> Iterable["_models.Activity"]: """Retrieve a list of activities in the module identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ActivityListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.ActivityListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Activity or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Activity] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ActivityListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ActivityListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_module_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, module_name=module_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_module.metadata['url'], + template_url=self.list_by_module.metadata["url"], headers=_headers, params=_params, ) @@ -252,17 +237,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_module_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - module_name=module_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -278,10 +253,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -292,8 +265,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_module.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities"} # type: ignore + list_by_module.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/activities"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_agent_registration_information_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_agent_registration_information_operations.py index dedc1e74ee1c..883282e802f7 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_agent_registration_information_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_agent_registration_information_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,93 +23,84 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_regenerate_key_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - *, - json: Optional[_models.AgentRegistrationRegenerateKeyParameter] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation/regenerateKey") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation/regenerateKey", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + class AgentRegistrationInformationOperations: """ @@ -126,46 +121,34 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace - def get( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> _models.AgentRegistration: + def get(self, resource_group_name: str, automation_account_name: str, **kwargs: Any) -> _models.AgentRegistration: """Retrieve the automation agent registration information. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AgentRegistration, or the result of cls(response) + :return: AgentRegistration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AgentRegistration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.AgentRegistration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.AgentRegistration] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -173,10 +156,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -184,62 +166,121 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('AgentRegistration', pipeline_response) + deserialized = self._deserialize("AgentRegistration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation"} # type: ignore - @distributed_trace + @overload def regenerate_key( self, resource_group_name: str, automation_account_name: str, parameters: _models.AgentRegistrationRegenerateKeyParameter, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.AgentRegistration: """Regenerate a primary or secondary agent registration key. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param parameters: The name of the agent registration key to be regenerated. + :param parameters: The name of the agent registration key to be regenerated. Required. :type parameters: ~azure.mgmt.automation.models.AgentRegistrationRegenerateKeyParameter - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AgentRegistration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AgentRegistration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def regenerate_key( + self, + resource_group_name: str, + automation_account_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AgentRegistration: + """Regenerate a primary or secondary agent registration key. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: The name of the agent registration key to be regenerated. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AgentRegistration, or the result of cls(response) + :return: AgentRegistration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AgentRegistration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def regenerate_key( + self, + resource_group_name: str, + automation_account_name: str, + parameters: Union[_models.AgentRegistrationRegenerateKeyParameter, IO], + **kwargs: Any + ) -> _models.AgentRegistration: + """Regenerate a primary or secondary agent registration key. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: The name of the agent registration key to be regenerated. Is either a model + type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.AgentRegistrationRegenerateKeyParameter or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AgentRegistration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AgentRegistration + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.AgentRegistration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.AgentRegistration] - _json = self._serialize.body(parameters, 'AgentRegistrationRegenerateKeyParameter') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "AgentRegistrationRegenerateKeyParameter") request = build_regenerate_key_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self.regenerate_key.metadata['url'], + content=_content, + template_url=self.regenerate_key.metadata["url"], headers=_headers, params=_params, ) @@ -247,10 +288,9 @@ def regenerate_key( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -258,12 +298,11 @@ def regenerate_key( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('AgentRegistration', pipeline_response) + deserialized = self._deserialize("AgentRegistration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - regenerate_key.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation/regenerateKey"} # type: ignore - + regenerate_key.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/agentRegistrationInformation/regenerateKey"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_automation_account_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_automation_account_operations.py index 777057c256cb..ed99480dce86 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_automation_account_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_automation_account_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,243 +24,209 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_update_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - *, - json: Optional[_models.AutomationAccountUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - *, - json: Optional[_models.AutomationAccountCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_delete_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_list_by_resource_group_request( - resource_group_name: str, - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +def build_list_by_resource_group_request(resource_group_name: str, subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_list_request( - subscription_id: str, - **kwargs: Any -) -> HttpRequest: + +def build_list_request(subscription_id: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/automationAccounts") + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/automationAccounts" + ) path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + class AutomationAccountOperations: """ @@ -277,44 +247,102 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, parameters: _models.AutomationAccountUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.AutomationAccount: """Update an automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param parameters: Parameters supplied to the update automation account. + :param parameters: Parameters supplied to the update automation account. Required. :type parameters: ~azure.mgmt.automation.models.AutomationAccountUpdateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AutomationAccount, or the result of cls(response) + :return: AutomationAccount or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AutomationAccount - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AutomationAccount: + """Update an automation account. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Parameters supplied to the update automation account. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AutomationAccount or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AutomationAccount + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + parameters: Union[_models.AutomationAccountUpdateParameters, IO], + **kwargs: Any + ) -> _models.AutomationAccount: + """Update an automation account. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Parameters supplied to the update automation account. Is either a model type + or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.AutomationAccountUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AutomationAccount or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AutomationAccount + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccount] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccount] - _json = self._serialize.body(parameters, 'AutomationAccountUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "AutomationAccountUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -323,7 +351,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -331,10 +360,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -342,53 +370,111 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('AutomationAccount', pipeline_response) + deserialized = self._deserialize("AutomationAccount", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, parameters: _models.AutomationAccountCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.AutomationAccount: """Create or update automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param parameters: Parameters supplied to the create or update automation account. + :param parameters: Parameters supplied to the create or update automation account. Required. :type parameters: ~azure.mgmt.automation.models.AutomationAccountCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AutomationAccount or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AutomationAccount + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AutomationAccount: + """Create or update automation account. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Parameters supplied to the create or update automation account. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AutomationAccount, or the result of cls(response) + :return: AutomationAccount or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AutomationAccount - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + parameters: Union[_models.AutomationAccountCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.AutomationAccount: + """Create or update automation account. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Parameters supplied to the create or update automation account. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.AutomationAccountCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AutomationAccount or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.AutomationAccount + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccount] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccount] - _json = self._serialize.body(parameters, 'AutomationAccountCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "AutomationAccountCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -397,7 +483,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -405,10 +492,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -417,58 +503,48 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('AutomationAccount', pipeline_response) + deserialized = self._deserialize("AutomationAccount", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('AutomationAccount', pipeline_response) + deserialized = self._deserialize("AutomationAccount", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, **kwargs: Any ) -> None: """Delete an automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -476,10 +552,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -490,48 +565,36 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore @distributed_trace - def get( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> _models.AutomationAccount: + def get(self, resource_group_name: str, automation_account_name: str, **kwargs: Any) -> _models.AutomationAccount: """Get information about an Automation Account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AutomationAccount, or the result of cls(response) + :return: AutomationAccount or the result of cls(response) :rtype: ~azure.mgmt.automation.models.AutomationAccount - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccount] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccount] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -539,10 +602,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -550,53 +612,43 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('AutomationAccount', pipeline_response) + deserialized = self._deserialize("AutomationAccount", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}"} # type: ignore @distributed_trace - def list_by_resource_group( - self, - resource_group_name: str, - **kwargs: Any - ) -> Iterable[_models.AutomationAccountListResult]: + def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Iterable["_models.AutomationAccount"]: """Retrieve a list of accounts within a given resource group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either AutomationAccountListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.AutomationAccountListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either AutomationAccount or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.AutomationAccount] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccountListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccountListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_resource_group_request( resource_group_name=resource_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_resource_group.metadata['url'], + template_url=self.list_by_resource_group.metadata["url"], headers=_headers, params=_params, ) @@ -604,15 +656,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_resource_group_request( - resource_group_name=resource_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -628,10 +672,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -642,47 +684,37 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_resource_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts"} # type: ignore + list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts"} # type: ignore @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.AutomationAccountListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.AutomationAccount"]: """Lists the Automation Accounts within an Azure subscription. Retrieve a list of accounts within a given subscription. - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either AutomationAccountListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.AutomationAccountListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either AutomationAccount or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.AutomationAccount] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.AutomationAccountListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.AutomationAccountListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_request( subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -690,14 +722,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -713,10 +738,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -727,8 +750,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/automationAccounts"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/automationAccounts"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_automation_client_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_automation_client_operations.py index 08c2b9f3c051..3954ec5036a1 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_automation_client_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_automation_client_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,96 +23,149 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_convert_graph_runbook_content_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - *, - json: Optional[_models.GraphicalRunbookContent] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/convertGraphRunbookContent") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/convertGraphRunbookContent", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") -class AutomationClientOperationsMixin(MixinABC): + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - @distributed_trace + +class AutomationClientOperationsMixin(MixinABC): + @overload def convert_graph_runbook_content( self, resource_group_name: str, automation_account_name: str, parameters: _models.GraphicalRunbookContent, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.GraphicalRunbookContent: """Post operation to serialize or deserialize GraphRunbookContent. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param parameters: Input data describing the graphical runbook. + :param parameters: Input data describing the graphical runbook. Required. :type parameters: ~azure.mgmt.automation.models.GraphicalRunbookContent - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: GraphicalRunbookContent, or the result of cls(response) + :return: GraphicalRunbookContent or the result of cls(response) :rtype: ~azure.mgmt.automation.models.GraphicalRunbookContent - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def convert_graph_runbook_content( + self, + resource_group_name: str, + automation_account_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.GraphicalRunbookContent: + """Post operation to serialize or deserialize GraphRunbookContent. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Input data describing the graphical runbook. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: GraphicalRunbookContent or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.GraphicalRunbookContent + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def convert_graph_runbook_content( + self, + resource_group_name: str, + automation_account_name: str, + parameters: Union[_models.GraphicalRunbookContent, IO], + **kwargs: Any + ) -> _models.GraphicalRunbookContent: + """Post operation to serialize or deserialize GraphRunbookContent. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param parameters: Input data describing the graphical runbook. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.GraphicalRunbookContent or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: GraphicalRunbookContent or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.GraphicalRunbookContent + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.GraphicalRunbookContent] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.GraphicalRunbookContent] - _json = self._serialize.body(parameters, 'GraphicalRunbookContent') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "GraphicalRunbookContent") request = build_convert_graph_runbook_content_request( resource_group_name=resource_group_name, @@ -117,7 +174,8 @@ def convert_graph_runbook_content( api_version=api_version, content_type=content_type, json=_json, - template_url=self.convert_graph_runbook_content.metadata['url'], + content=_content, + template_url=self.convert_graph_runbook_content.metadata["url"], headers=_headers, params=_params, ) @@ -125,10 +183,9 @@ def convert_graph_runbook_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -136,12 +193,11 @@ def convert_graph_runbook_content( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('GraphicalRunbookContent', pipeline_response) + deserialized = self._deserialize("GraphicalRunbookContent", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - convert_graph_runbook_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/convertGraphRunbookContent"} # type: ignore - + convert_graph_runbook_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/convertGraphRunbookContent"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_certificate_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_certificate_operations.py index 198c3340d81c..ee028959e399 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_certificate_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_certificate_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,220 +24,190 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - resource_group_name: str, - automation_account_name: str, - certificate_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, certificate_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "certificateName": _SERIALIZER.url("certificate_name", certificate_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "certificateName": _SERIALIZER.url("certificate_name", certificate_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - certificate_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, certificate_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "certificateName": _SERIALIZER.url("certificate_name", certificate_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "certificateName": _SERIALIZER.url("certificate_name", certificate_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - certificate_name: str, - subscription_id: str, - *, - json: Optional[_models.CertificateCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, certificate_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "certificateName": _SERIALIZER.url("certificate_name", certificate_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "certificateName": _SERIALIZER.url("certificate_name", certificate_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - certificate_name: str, - subscription_id: str, - *, - json: Optional[_models.CertificateUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, certificate_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "certificateName": _SERIALIZER.url("certificate_name", certificate_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "certificateName": _SERIALIZER.url("certificate_name", certificate_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class CertificateOperations: """ @@ -254,50 +228,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - certificate_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, certificate_name: str, **kwargs: Any ) -> None: """Delete the certificate. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param certificate_name: The name of certificate. + :param certificate_name: The name of certificate. Required. :type certificate_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, certificate_name=certificate_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +268,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -319,52 +281,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - certificate_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, certificate_name: str, **kwargs: Any ) -> _models.Certificate: """Retrieve the certificate identified by certificate name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param certificate_name: The name of certificate. + :param certificate_name: The name of certificate. Required. :type certificate_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Certificate, or the result of cls(response) + :return: Certificate or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Certificate - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Certificate] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Certificate] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, certificate_name=certificate_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -372,10 +323,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -383,56 +333,125 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Certificate', pipeline_response) + deserialized = self._deserialize("Certificate", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, certificate_name: str, parameters: _models.CertificateCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Certificate: """Create a certificate. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param certificate_name: The parameters supplied to the create or update certificate operation. + Required. :type certificate_name: str :param parameters: The parameters supplied to the create or update certificate operation. + Required. :type parameters: ~azure.mgmt.automation.models.CertificateCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Certificate or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Certificate + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + certificate_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Certificate: + """Create a certificate. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param certificate_name: The parameters supplied to the create or update certificate operation. + Required. + :type certificate_name: str + :param parameters: The parameters supplied to the create or update certificate operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Certificate or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Certificate + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + certificate_name: str, + parameters: Union[_models.CertificateCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Certificate: + """Create a certificate. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param certificate_name: The parameters supplied to the create or update certificate operation. + Required. + :type certificate_name: str + :param parameters: The parameters supplied to the create or update certificate operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.CertificateCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Certificate, or the result of cls(response) + :return: Certificate or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Certificate - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Certificate] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Certificate] - _json = self._serialize.body(parameters, 'CertificateCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "CertificateCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -442,7 +461,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -450,10 +470,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -462,59 +481,123 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Certificate', pipeline_response) + deserialized = self._deserialize("Certificate", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Certificate', pipeline_response) + deserialized = self._deserialize("Certificate", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, certificate_name: str, parameters: _models.CertificateUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Certificate: """Update a certificate. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param certificate_name: The parameters supplied to the update certificate operation. + :param certificate_name: The parameters supplied to the update certificate operation. Required. :type certificate_name: str - :param parameters: The parameters supplied to the update certificate operation. + :param parameters: The parameters supplied to the update certificate operation. Required. :type parameters: ~azure.mgmt.automation.models.CertificateUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Certificate or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Certificate + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + certificate_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Certificate: + """Update a certificate. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param certificate_name: The parameters supplied to the update certificate operation. Required. + :type certificate_name: str + :param parameters: The parameters supplied to the update certificate operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Certificate, or the result of cls(response) + :return: Certificate or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Certificate - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + certificate_name: str, + parameters: Union[_models.CertificateUpdateParameters, IO], + **kwargs: Any + ) -> _models.Certificate: + """Update a certificate. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param certificate_name: The parameters supplied to the update certificate operation. Required. + :type certificate_name: str + :param parameters: The parameters supplied to the update certificate operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.CertificateUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Certificate or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Certificate + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Certificate] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Certificate] - _json = self._serialize.body(parameters, 'CertificateUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "CertificateUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -524,7 +607,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -532,10 +616,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -543,57 +626,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Certificate', pipeline_response) + deserialized = self._deserialize("Certificate", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates/{certificateName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.CertificateListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Certificate"]: """Retrieve a list of certificates. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either CertificateListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.CertificateListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Certificate or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Certificate] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.CertificateListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.CertificateListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -601,16 +675,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -626,10 +691,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -640,8 +703,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/certificates"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_connection_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_connection_operations.py index d8936531f423..41b2fcd1fe6a 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_connection_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_connection_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,220 +24,190 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - resource_group_name: str, - automation_account_name: str, - connection_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, connection_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "connectionName": _SERIALIZER.url("connection_name", connection_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "connectionName": _SERIALIZER.url("connection_name", connection_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - connection_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, connection_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "connectionName": _SERIALIZER.url("connection_name", connection_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "connectionName": _SERIALIZER.url("connection_name", connection_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - connection_name: str, - subscription_id: str, - *, - json: Optional[_models.ConnectionCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, connection_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "connectionName": _SERIALIZER.url("connection_name", connection_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "connectionName": _SERIALIZER.url("connection_name", connection_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - connection_name: str, - subscription_id: str, - *, - json: Optional[_models.ConnectionUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, connection_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "connectionName": _SERIALIZER.url("connection_name", connection_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "connectionName": _SERIALIZER.url("connection_name", connection_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ConnectionOperations: """ @@ -254,50 +228,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - connection_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, connection_name: str, **kwargs: Any ) -> None: """Delete the connection. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_name: The name of connection. + :param connection_name: The name of connection. Required. :type connection_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, connection_name=connection_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +268,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -319,52 +281,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - connection_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, connection_name: str, **kwargs: Any ) -> _models.Connection: """Retrieve the connection identified by connection name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_name: The name of connection. + :param connection_name: The name of connection. Required. :type connection_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Connection, or the result of cls(response) + :return: Connection or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Connection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Connection] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Connection] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, connection_name=connection_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -372,10 +323,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -383,56 +333,125 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Connection', pipeline_response) + deserialized = self._deserialize("Connection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, connection_name: str, parameters: _models.ConnectionCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Connection: """Create or update a connection. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param connection_name: The parameters supplied to the create or update connection operation. + Required. :type connection_name: str :param parameters: The parameters supplied to the create or update connection operation. + Required. :type parameters: ~azure.mgmt.automation.models.ConnectionCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Connection or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Connection + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + connection_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Connection: + """Create or update a connection. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_name: The parameters supplied to the create or update connection operation. + Required. + :type connection_name: str + :param parameters: The parameters supplied to the create or update connection operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Connection or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Connection + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + connection_name: str, + parameters: Union[_models.ConnectionCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Connection: + """Create or update a connection. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_name: The parameters supplied to the create or update connection operation. + Required. + :type connection_name: str + :param parameters: The parameters supplied to the create or update connection operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ConnectionCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Connection, or the result of cls(response) + :return: Connection or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Connection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Connection] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Connection] - _json = self._serialize.body(parameters, 'ConnectionCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ConnectionCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -442,7 +461,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -450,10 +470,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -462,59 +481,123 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Connection', pipeline_response) + deserialized = self._deserialize("Connection", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Connection', pipeline_response) + deserialized = self._deserialize("Connection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, connection_name: str, parameters: _models.ConnectionUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Connection: """Update a connection. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_name: The parameters supplied to the update a connection operation. + :param connection_name: The parameters supplied to the update a connection operation. Required. :type connection_name: str - :param parameters: The parameters supplied to the update a connection operation. + :param parameters: The parameters supplied to the update a connection operation. Required. :type parameters: ~azure.mgmt.automation.models.ConnectionUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Connection or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Connection + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + connection_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Connection: + """Update a connection. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_name: The parameters supplied to the update a connection operation. Required. + :type connection_name: str + :param parameters: The parameters supplied to the update a connection operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Connection, or the result of cls(response) + :return: Connection or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Connection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + connection_name: str, + parameters: Union[_models.ConnectionUpdateParameters, IO], + **kwargs: Any + ) -> _models.Connection: + """Update a connection. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_name: The parameters supplied to the update a connection operation. Required. + :type connection_name: str + :param parameters: The parameters supplied to the update a connection operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ConnectionUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Connection or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Connection + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Connection] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Connection] - _json = self._serialize.body(parameters, 'ConnectionUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ConnectionUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -524,7 +607,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -532,10 +616,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -543,57 +626,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Connection', pipeline_response) + deserialized = self._deserialize("Connection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections/{connectionName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.ConnectionListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Connection"]: """Retrieve a list of connections. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ConnectionListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.ConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Connection or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Connection] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -601,16 +675,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -626,10 +691,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -640,8 +703,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connections"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_connection_type_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_connection_type_operations.py index 186dafb7e07f..ed22f05798ff 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_connection_type_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_connection_type_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +24,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( resource_group_name: str, automation_account_name: str, @@ -37,33 +44,32 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "connectionTypeName": _SERIALIZER.url("connection_type_name", connection_type_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "connectionTypeName": _SERIALIZER.url("connection_type_name", connection_type_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( @@ -76,33 +82,32 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "connectionTypeName": _SERIALIZER.url("connection_type_name", connection_type_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "connectionTypeName": _SERIALIZER.url("connection_type_name", connection_type_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( @@ -110,83 +115,74 @@ def build_create_or_update_request( automation_account_name: str, connection_type_name: str, subscription_id: str, - *, - json: Optional[_models.ConnectionTypeCreateOrUpdateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "connectionTypeName": _SERIALIZER.url("connection_type_name", connection_type_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "connectionTypeName": _SERIALIZER.url("connection_type_name", connection_type_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ConnectionTypeOperations: """ @@ -207,50 +203,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - connection_type_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, connection_type_name: str, **kwargs: Any ) -> None: """Delete the connection type. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_type_name: The name of connection type. + :param connection_type_name: The name of connection type. Required. :type connection_type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, connection_type_name=connection_type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -258,10 +243,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -272,52 +256,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - connection_type_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, connection_type_name: str, **kwargs: Any ) -> _models.ConnectionType: """Retrieve the connection type identified by connection type name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param connection_type_name: The name of connection type. + :param connection_type_name: The name of connection type. Required. :type connection_type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ConnectionType, or the result of cls(response) + :return: ConnectionType or the result of cls(response) :rtype: ~azure.mgmt.automation.models.ConnectionType - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ConnectionType] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionType] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, connection_type_name=connection_type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -325,10 +298,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -336,57 +308,125 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ConnectionType', pipeline_response) + deserialized = self._deserialize("ConnectionType", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore - - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, connection_type_name: str, parameters: _models.ConnectionTypeCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.ConnectionType: """Create a connection type. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param connection_type_name: The parameters supplied to the create or update connection type - operation. + operation. Required. :type connection_type_name: str :param parameters: The parameters supplied to the create or update connection type operation. + Required. :type parameters: ~azure.mgmt.automation.models.ConnectionTypeCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ConnectionType, or the result of cls(response) + :return: ConnectionType or the result of cls(response) :rtype: ~azure.mgmt.automation.models.ConnectionType - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + connection_type_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ConnectionType: + """Create a connection type. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_type_name: The parameters supplied to the create or update connection type + operation. Required. + :type connection_type_name: str + :param parameters: The parameters supplied to the create or update connection type operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: ConnectionType or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.ConnectionType + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + connection_type_name: str, + parameters: Union[_models.ConnectionTypeCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.ConnectionType: + """Create a connection type. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param connection_type_name: The parameters supplied to the create or update connection type + operation. Required. + :type connection_type_name: str + :param parameters: The parameters supplied to the create or update connection type operation. + Is either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ConnectionTypeCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: ConnectionType or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.ConnectionType + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.ConnectionType] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionType] - _json = self._serialize.body(parameters, 'ConnectionTypeCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ConnectionTypeCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -396,7 +436,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -404,10 +445,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -415,57 +455,48 @@ def create_or_update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('ConnectionType', pipeline_response) + deserialized = self._deserialize("ConnectionType", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes/{connectionTypeName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.ConnectionTypeListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.ConnectionType"]: """Retrieve a list of connection types. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ConnectionTypeListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.ConnectionTypeListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ConnectionType or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.ConnectionType] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ConnectionTypeListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ConnectionTypeListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -473,16 +504,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -498,10 +520,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -512,8 +532,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/connectionTypes"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_credential_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_credential_operations.py index f62ddd61f2fe..880d8ab2f96a 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_credential_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_credential_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,220 +24,190 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - resource_group_name: str, - automation_account_name: str, - credential_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, credential_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "credentialName": _SERIALIZER.url("credential_name", credential_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "credentialName": _SERIALIZER.url("credential_name", credential_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - credential_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, credential_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "credentialName": _SERIALIZER.url("credential_name", credential_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "credentialName": _SERIALIZER.url("credential_name", credential_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - credential_name: str, - subscription_id: str, - *, - json: Optional[_models.CredentialCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, credential_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "credentialName": _SERIALIZER.url("credential_name", credential_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "credentialName": _SERIALIZER.url("credential_name", credential_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - credential_name: str, - subscription_id: str, - *, - json: Optional[_models.CredentialUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, credential_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "credentialName": _SERIALIZER.url("credential_name", credential_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "credentialName": _SERIALIZER.url("credential_name", credential_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class CredentialOperations: """ @@ -254,50 +228,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - credential_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, credential_name: str, **kwargs: Any ) -> None: """Delete the credential. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param credential_name: The name of credential. + :param credential_name: The name of credential. Required. :type credential_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, credential_name=credential_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +268,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -319,52 +281,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - credential_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, credential_name: str, **kwargs: Any ) -> _models.Credential: """Retrieve the credential identified by credential name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param credential_name: The name of credential. + :param credential_name: The name of credential. Required. :type credential_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Credential, or the result of cls(response) + :return: Credential or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Credential - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Credential] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Credential] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, credential_name=credential_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -372,10 +323,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -383,56 +333,125 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Credential', pipeline_response) + deserialized = self._deserialize("Credential", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, credential_name: str, parameters: _models.CredentialCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Credential: """Create a credential. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param credential_name: The parameters supplied to the create or update credential operation. + Required. :type credential_name: str :param parameters: The parameters supplied to the create or update credential operation. + Required. :type parameters: ~azure.mgmt.automation.models.CredentialCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Credential or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Credential + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + credential_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Credential: + """Create a credential. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param credential_name: The parameters supplied to the create or update credential operation. + Required. + :type credential_name: str + :param parameters: The parameters supplied to the create or update credential operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Credential or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Credential + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + credential_name: str, + parameters: Union[_models.CredentialCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Credential: + """Create a credential. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param credential_name: The parameters supplied to the create or update credential operation. + Required. + :type credential_name: str + :param parameters: The parameters supplied to the create or update credential operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.CredentialCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Credential, or the result of cls(response) + :return: Credential or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Credential - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Credential] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Credential] - _json = self._serialize.body(parameters, 'CredentialCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "CredentialCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -442,7 +461,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -450,10 +470,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -462,59 +481,123 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Credential', pipeline_response) + deserialized = self._deserialize("Credential", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Credential', pipeline_response) + deserialized = self._deserialize("Credential", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, credential_name: str, parameters: _models.CredentialUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Credential: """Update a credential. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param credential_name: The parameters supplied to the Update credential operation. + :param credential_name: The parameters supplied to the Update credential operation. Required. :type credential_name: str - :param parameters: The parameters supplied to the Update credential operation. + :param parameters: The parameters supplied to the Update credential operation. Required. :type parameters: ~azure.mgmt.automation.models.CredentialUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Credential or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Credential + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + credential_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Credential: + """Update a credential. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param credential_name: The parameters supplied to the Update credential operation. Required. + :type credential_name: str + :param parameters: The parameters supplied to the Update credential operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Credential, or the result of cls(response) + :return: Credential or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Credential - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + credential_name: str, + parameters: Union[_models.CredentialUpdateParameters, IO], + **kwargs: Any + ) -> _models.Credential: + """Update a credential. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param credential_name: The parameters supplied to the Update credential operation. Required. + :type credential_name: str + :param parameters: The parameters supplied to the Update credential operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.CredentialUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Credential or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Credential + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Credential] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Credential] - _json = self._serialize.body(parameters, 'CredentialUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "CredentialUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -524,7 +607,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -532,10 +616,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -543,57 +626,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Credential', pipeline_response) + deserialized = self._deserialize("Credential", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials/{credentialName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.CredentialListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Credential"]: """Retrieve a list of credentials. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either CredentialListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.CredentialListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Credential or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Credential] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.CredentialListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.CredentialListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -601,16 +675,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -626,10 +691,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -639,8 +702,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/credentials"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_deleted_automation_accounts_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_deleted_automation_accounts_operations.py new file mode 100644 index 000000000000..81fc7c0650d0 --- /dev/null +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_deleted_automation_accounts_operations.py @@ -0,0 +1,127 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from typing import Any, Callable, Dict, Optional, TypeVar + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.pipeline.transport import HttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from .. import models as _models +from .._serialization import Serializer +from .._vendor import MixinABC, _convert_request, _format_url_section + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_list_by_subscription_request(subscription_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-31")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/deletedAutomationAccounts" + ) # pylint: disable=line-too-long + path_format_arguments = { + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +class DeletedAutomationAccountsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.automation.AutomationClient`'s + :attr:`deleted_automation_accounts` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> _models.DeletedAutomationAccountListResult: + """Retrieve deleted automation account. + + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DeletedAutomationAccountListResult or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DeletedAutomationAccountListResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DeletedAutomationAccountListResult] + + request = build_list_by_subscription_request( + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.list_by_subscription.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("DeletedAutomationAccountListResult", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + list_by_subscription.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.Automation/deletedAutomationAccounts"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_compilation_job_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_compilation_job_operations.py index c4317fb77256..ea6fc188bd9f 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_compilation_job_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_compilation_job_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, cast, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -22,58 +26,55 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False -def build_create_request_initial( + +def build_create_request( resource_group_name: str, automation_account_name: str, compilation_job_name: str, subscription_id: str, - *, - json: Optional[_models.DscCompilationJobCreateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "compilationJobName": _SERIALIZER.url("compilation_job_name", compilation_job_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "compilationJobName": _SERIALIZER.url("compilation_job_name", compilation_job_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( @@ -86,33 +87,32 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "compilationJobName": _SERIALIZER.url("compilation_job_name", compilation_job_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "compilationJobName": _SERIALIZER.url("compilation_job_name", compilation_job_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -126,34 +126,33 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_stream_request( @@ -167,34 +166,34 @@ def build_get_stream_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams/{jobStreamId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams/{jobStreamId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobId": _SERIALIZER.url("job_id", job_id, 'str'), - "jobStreamId": _SERIALIZER.url("job_stream_id", job_stream_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobId": _SERIALIZER.url("job_id", job_id, "str"), + "jobStreamId": _SERIALIZER.url("job_stream_id", job_stream_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class DscCompilationJobOperations: """ @@ -215,30 +214,33 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - def _create_initial( self, resource_group_name: str, automation_account_name: str, compilation_job_name: str, - parameters: _models.DscCompilationJobCreateParameters, + parameters: Union[_models.DscCompilationJobCreateParameters, IO], **kwargs: Any ) -> _models.DscCompilationJob: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscCompilationJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscCompilationJob] - _json = self._serialize.body(parameters, 'DscCompilationJobCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "DscCompilationJobCreateParameters") - request = build_create_request_initial( + request = build_create_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, compilation_job_name=compilation_job_name, @@ -246,7 +248,8 @@ def _create_initial( api_version=api_version, content_type=content_type, json=_json, - template_url=self._create_initial.metadata['url'], + content=_content, + template_url=self._create_initial.metadata["url"], headers=_headers, params=_params, ) @@ -254,48 +257,124 @@ def _create_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscCompilationJob', pipeline_response) + deserialized = self._deserialize("DscCompilationJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore - + _create_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore - @distributed_trace + @overload def begin_create( self, resource_group_name: str, automation_account_name: str, compilation_job_name: str, parameters: _models.DscCompilationJobCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> LROPoller[_models.DscCompilationJob]: """Creates the Dsc compilation job of the configuration. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param compilation_job_name: The DSC configuration Id. + :param compilation_job_name: The DSC configuration Id. Required. :type compilation_job_name: str - :param parameters: The parameters supplied to the create compilation job operation. + :param parameters: The parameters supplied to the create compilation job operation. Required. :type parameters: ~azure.mgmt.automation.models.DscCompilationJobCreateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either DscCompilationJob or the result of + cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.DscCompilationJob] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create( + self, + resource_group_name: str, + automation_account_name: str, + compilation_job_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.DscCompilationJob]: + """Creates the Dsc compilation job of the configuration. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param compilation_job_name: The DSC configuration Id. Required. + :type compilation_job_name: str + :param parameters: The parameters supplied to the create compilation job operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either DscCompilationJob or the result of + cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.DscCompilationJob] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_create( + self, + resource_group_name: str, + automation_account_name: str, + compilation_job_name: str, + parameters: Union[_models.DscCompilationJobCreateParameters, IO], + **kwargs: Any + ) -> LROPoller[_models.DscCompilationJob]: + """Creates the Dsc compilation job of the configuration. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param compilation_job_name: The DSC configuration Id. Required. + :type compilation_job_name: str + :param parameters: The parameters supplied to the create compilation job operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.DscCompilationJobCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -307,20 +386,17 @@ def begin_create( :return: An instance of LROPoller that returns either DscCompilationJob or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.DscCompilationJob] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscCompilationJob] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscCompilationJob] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_initial( # type: ignore resource_group_name=resource_group_name, @@ -329,83 +405,69 @@ def begin_create( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('DscCompilationJob', pipeline_response) + deserialized = self._deserialize("DscCompilationJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore + begin_create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - compilation_job_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, compilation_job_name: str, **kwargs: Any ) -> _models.DscCompilationJob: """Retrieve the Dsc configuration compilation job identified by job id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param compilation_job_name: The DSC configuration Id. + :param compilation_job_name: The DSC configuration Id. Required. :type compilation_job_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscCompilationJob, or the result of cls(response) + :return: DscCompilationJob or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscCompilationJob - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscCompilationJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscCompilationJob] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, compilation_job_name=compilation_job_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -413,10 +475,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -424,61 +485,51 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscCompilationJob', pipeline_response) + deserialized = self._deserialize("DscCompilationJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{compilationJobName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> Iterable[_models.DscCompilationJobListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.DscCompilationJob"]: """Retrieve a list of dsc compilation jobs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscCompilationJobListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscCompilationJobListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either DscCompilationJob or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscCompilationJob] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscCompilationJobListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscCompilationJobListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -486,17 +537,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -512,10 +553,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -526,51 +565,38 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs"} # type: ignore @distributed_trace def get_stream( - self, - resource_group_name: str, - automation_account_name: str, - job_id: str, - job_stream_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, job_id: str, job_stream_id: str, **kwargs: Any ) -> _models.JobStream: """Retrieve the job stream identified by job stream id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_id: The job id. + :param job_id: The job id. Required. :type job_id: str - :param job_stream_id: The job stream id. + :param job_stream_id: The job stream id. Required. :type job_stream_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobStream, or the result of cls(response) + :return: JobStream or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobStream - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStream] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStream] - request = build_get_stream_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -578,7 +604,7 @@ def get_stream( job_stream_id=job_stream_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_stream.metadata['url'], + template_url=self.get_stream.metadata["url"], headers=_headers, params=_params, ) @@ -586,10 +612,9 @@ def get_stream( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -597,12 +622,11 @@ def get_stream( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobStream', pipeline_response) + deserialized = self._deserialize("JobStream", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_stream.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams/{jobStreamId}"} # type: ignore - + get_stream.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams/{jobStreamId}"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_compilation_job_stream_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_compilation_job_stream_operations.py index cc82aafc6349..63bed2100b80 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_compilation_job_stream_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_compilation_job_stream_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,50 +23,49 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_by_job_request( - resource_group_name: str, - automation_account_name: str, - job_id: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, job_id: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobId": _SERIALIZER.url("job_id", job_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobId": _SERIALIZER.url("job_id", job_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class DscCompilationJobStreamOperations: """ @@ -83,50 +86,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_job( - self, - resource_group_name: str, - automation_account_name: str, - job_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, job_id: str, **kwargs: Any ) -> _models.JobStreamListResult: """Retrieve all the job streams for the compilation Job. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_id: The job id. + :param job_id: The job id. Required. :type job_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobStreamListResult, or the result of cls(response) + :return: JobStreamListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobStreamListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStreamListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStreamListResult] - request = build_list_by_job_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_id=job_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_job.metadata['url'], + template_url=self.list_by_job.metadata["url"], headers=_headers, params=_params, ) @@ -134,10 +126,9 @@ def list_by_job( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -145,12 +136,11 @@ def list_by_job( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobStreamListResult', pipeline_response) + deserialized = self._deserialize("JobStreamListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_job.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams"} # type: ignore - + list_by_job.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/compilationjobs/{jobId}/streams"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_configuration_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_configuration_operations.py index 6cd7d107baec..5f28cf3ae671 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_configuration_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_configuration_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, Union - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, Iterable, Iterator, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,222 +24,190 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, configuration_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "configurationName": _SERIALIZER.url("configuration_name", configuration_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, configuration_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "configurationName": _SERIALIZER.url("configuration_name", configuration_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - subscription_id: str, - *, - json: Optional[_models.DscConfigurationCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, configuration_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "configurationName": _SERIALIZER.url("configuration_name", configuration_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - subscription_id: str, - *, - json: Optional[_models.DscConfigurationUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, configuration_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "configurationName": _SERIALIZER.url("configuration_name", configuration_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_get_content_request( - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, configuration_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "text/powershell") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "text/powershell") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}/content") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}/content", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "configurationName": _SERIALIZER.url("configuration_name", configuration_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -252,40 +224,40 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") if skip is not None: - _params['$skip'] = _SERIALIZER.query("skip", skip, 'int') + _params["$skip"] = _SERIALIZER.query("skip", skip, "int") if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') + _params["$top"] = _SERIALIZER.query("top", top, "int") if inlinecount is not None: - _params['$inlinecount'] = _SERIALIZER.query("inlinecount", inlinecount, 'str') + _params["$inlinecount"] = _SERIALIZER.query("inlinecount", inlinecount, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class DscConfigurationOperations: """ @@ -306,50 +278,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, configuration_name: str, **kwargs: Any ) -> None: """Delete the dsc configuration identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The configuration name. + :param configuration_name: The configuration name. Required. :type configuration_name: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, configuration_name=configuration_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -357,10 +318,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -371,52 +331,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, configuration_name: str, **kwargs: Any ) -> _models.DscConfiguration: """Retrieve the configuration identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The configuration name. + :param configuration_name: The configuration name. Required. :type configuration_name: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscConfiguration, or the result of cls(response) + :return: DscConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscConfiguration] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, configuration_name=configuration_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -424,10 +373,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -435,71 +383,120 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscConfiguration', pipeline_response) + deserialized = self._deserialize("DscConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + configuration_name: str, + parameters: _models.DscConfigurationCreateOrUpdateParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.DscConfiguration: + """Create the configuration identified by configuration name. - @distributed_trace + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param configuration_name: The create or update parameters for configuration. Required. + :type configuration_name: str + :param parameters: The create or update parameters for configuration. Required. + :type parameters: ~azure.mgmt.automation.models.DscConfigurationCreateOrUpdateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, configuration_name: str, - parameters: Union[str, _models.DscConfigurationCreateOrUpdateParameters], + parameters: str, *, - content_type: Optional[str] = "application/json", + content_type: Optional[str] = None, **kwargs: Any ) -> _models.DscConfiguration: """Create the configuration identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The create or update parameters for configuration. + :param configuration_name: The create or update parameters for configuration. Required. :type configuration_name: str - :param parameters: The create or update parameters for configuration. - :type parameters: str or ~azure.mgmt.automation.models.DscConfigurationCreateOrUpdateParameters - :keyword content_type: Media type of the body sent to the API. Known values are: "text/plain; - charset=utf-8" or "application/json". Default value is "application/json". + :param parameters: The create or update parameters for configuration. Required. + :type parameters: str + :keyword content_type: Body Parameter content-type. Content type parameter for string body. + Default value is None. :paramtype content_type: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscConfiguration, or the result of cls(response) + :return: DscConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) - _headers = kwargs.pop("headers", {}) or {} + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + configuration_name: str, + parameters: Union[_models.DscConfigurationCreateOrUpdateParameters, str], + **kwargs: Any + ) -> _models.DscConfiguration: + """Create the configuration identified by configuration name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param configuration_name: The create or update parameters for configuration. Required. + :type configuration_name: str + :param parameters: The create or update parameters for configuration. Is either a model type or + a string type. Required. + :type parameters: ~azure.mgmt.automation.models.DscConfigurationCreateOrUpdateParameters or str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json', + 'text/plain; charset=utf-8'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscConfiguration] _json = None _content = None - content_type = content_type or "" - if content_type.split(";")[0] in ['application/json']: - _json = parameters - elif content_type.split(";")[0] in ['text/plain']: - _content = parameters - else: - raise ValueError( - "The content_type '{}' is not one of the allowed values: " - "['text/plain; charset=utf-8', 'application/json']".format(content_type) - ) + if isinstance(parameters, msrest.Model): + content_type = content_type or "application/json" + _json = self._serialize.body(parameters, "DscConfigurationCreateOrUpdateParameters") + elif isinstance(parameters, str): + _content = self._serialize.body(parameters, "str") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -510,7 +507,7 @@ def create_or_update( content_type=content_type, json=_json, content=_content, - template_url=self.create_or_update.metadata['url'], + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -518,10 +515,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -530,74 +526,129 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('DscConfiguration', pipeline_response) + deserialized = self._deserialize("DscConfiguration", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('DscConfiguration', pipeline_response) + deserialized = self._deserialize("DscConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + configuration_name: str, + parameters: Optional[_models.DscConfigurationUpdateParameters] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.DscConfiguration: + """Create the configuration identified by configuration name. - @distributed_trace + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param configuration_name: The create or update parameters for configuration. Required. + :type configuration_name: str + :param parameters: The create or update parameters for configuration. Default value is None. + :type parameters: ~azure.mgmt.automation.models.DscConfigurationUpdateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload def update( self, resource_group_name: str, automation_account_name: str, configuration_name: str, - parameters: Optional[Union[str, _models.DscConfigurationUpdateParameters]] = None, + parameters: Optional[str] = None, *, - content_type: Optional[str] = "application/json", + content_type: Optional[str] = None, **kwargs: Any ) -> _models.DscConfiguration: """Create the configuration identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The create or update parameters for configuration. + :param configuration_name: The create or update parameters for configuration. Required. :type configuration_name: str :param parameters: The create or update parameters for configuration. Default value is None. - :type parameters: str or ~azure.mgmt.automation.models.DscConfigurationUpdateParameters - :keyword content_type: Media type of the body sent to the API. Known values are: "text/plain; - charset=utf-8" or "application/json". Default value is "application/json". + :type parameters: str + :keyword content_type: Body Parameter content-type. Content type parameter for string body. + Default value is None. :paramtype content_type: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscConfiguration, or the result of cls(response) + :return: DscConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) - _headers = kwargs.pop("headers", {}) or {} + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + configuration_name: str, + parameters: Optional[Union[_models.DscConfigurationUpdateParameters, str]] = None, + **kwargs: Any + ) -> _models.DscConfiguration: + """Create the configuration identified by configuration name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param configuration_name: The create or update parameters for configuration. Required. + :type configuration_name: str + :param parameters: The create or update parameters for configuration. Is either a model type or + a string type. Default value is None. + :type parameters: ~azure.mgmt.automation.models.DscConfigurationUpdateParameters or str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json', + 'text/plain; charset=utf-8'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscConfiguration] _json = None _content = None - content_type = content_type or "" - if content_type.split(";")[0] in ['application/json']: - _json = parameters - elif content_type.split(";")[0] in ['text/plain']: - _content = parameters - else: - raise ValueError( - "The content_type '{}' is not one of the allowed values: " - "['text/plain; charset=utf-8', 'application/json']".format(content_type) - ) + if isinstance(parameters, msrest.Model): + content_type = content_type or "application/json" + if parameters is not None: + _json = self._serialize.body(parameters, "DscConfigurationUpdateParameters") + else: + _json = None + elif isinstance(parameters, str): + if parameters is not None: + _content = self._serialize.body(parameters, "str") + else: + _content = None request = build_update_request( resource_group_name=resource_group_name, @@ -608,7 +659,7 @@ def update( content_type=content_type, json=_json, content=_content, - template_url=self.update.metadata['url'], + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -616,10 +667,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -627,59 +677,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscConfiguration', pipeline_response) + deserialized = self._deserialize("DscConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}"} # type: ignore @distributed_trace def get_content( - self, - resource_group_name: str, - automation_account_name: str, - configuration_name: str, - **kwargs: Any - ) -> str: + self, resource_group_name: str, automation_account_name: str, configuration_name: str, **kwargs: Any + ) -> Iterator[bytes]: """Retrieve the configuration script identified by configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param configuration_name: The configuration name. + :param configuration_name: The configuration name. Required. :type configuration_name: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: str, or the result of cls(response) - :rtype: str - :raises: ~azure.core.exceptions.HttpResponseError + :return: Iterator of the response bytes or the result of cls(response) + :rtype: Iterator[bytes] + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Iterator[bytes]] - request = build_get_content_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, configuration_name=configuration_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_content.metadata['url'], + template_url=self.get_content.metadata["url"], headers=_headers, params=_params, ) @@ -687,25 +726,23 @@ def get_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=True, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('str', pipeline_response) + deserialized = response.stream_download(self._client._pipeline) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}/content"} # type: ignore - + get_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations/{configurationName}/content"} # type: ignore @distributed_trace def list_by_automation_account( @@ -717,12 +754,12 @@ def list_by_automation_account( top: Optional[int] = None, inlinecount: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.DscConfigurationListResult]: + ) -> Iterable["_models.DscConfiguration"]: """Retrieve a list of configurations. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str @@ -732,38 +769,33 @@ def list_by_automation_account( :type top: int :param inlinecount: Return total rows. Default value is None. :type inlinecount: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscConfigurationListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscConfigurationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either DscConfiguration or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscConfiguration] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscConfigurationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscConfigurationListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, skip=skip, top=top, inlinecount=inlinecount, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -771,20 +803,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - skip=skip, - top=top, - inlinecount=inlinecount, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -800,10 +819,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -814,8 +831,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/configurations"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_node_configuration_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_node_configuration_operations.py index 45a99bb44475..324ea3bf7d8a 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_node_configuration_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_node_configuration_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, cast, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -22,136 +26,131 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, node_configuration_name: str, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeConfigurationName": _SERIALIZER.url("node_configuration_name", node_configuration_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeConfigurationName": _SERIALIZER.url("node_configuration_name", node_configuration_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, node_configuration_name: str, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeConfigurationName": _SERIALIZER.url("node_configuration_name", node_configuration_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeConfigurationName": _SERIALIZER.url("node_configuration_name", node_configuration_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_create_or_update_request_initial( +def build_create_or_update_request( resource_group_name: str, automation_account_name: str, node_configuration_name: str, subscription_id: str, - *, - json: Optional[_models.DscNodeConfigurationCreateOrUpdateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeConfigurationName": _SERIALIZER.url("node_configuration_name", node_configuration_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeConfigurationName": _SERIALIZER.url("node_configuration_name", node_configuration_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -168,40 +167,40 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") if skip is not None: - _params['$skip'] = _SERIALIZER.query("skip", skip, 'int') + _params["$skip"] = _SERIALIZER.query("skip", skip, "int") if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') + _params["$top"] = _SERIALIZER.query("top", top, "int") if inlinecount is not None: - _params['$inlinecount'] = _SERIALIZER.query("inlinecount", inlinecount, 'str') + _params["$inlinecount"] = _SERIALIZER.query("inlinecount", inlinecount, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class DscNodeConfigurationOperations: """ @@ -222,50 +221,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - node_configuration_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_configuration_name: str, **kwargs: Any ) -> None: """Delete the Dsc node configurations by node configuration. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_configuration_name: The Dsc node configuration name. + :param node_configuration_name: The Dsc node configuration name. Required. :type node_configuration_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_configuration_name=node_configuration_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -273,10 +261,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -287,52 +274,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - node_configuration_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_configuration_name: str, **kwargs: Any ) -> _models.DscNodeConfiguration: """Retrieve the Dsc node configurations by node configuration. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_configuration_name: The Dsc node configuration name. + :param node_configuration_name: The Dsc node configuration name. Required. :type node_configuration_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscNodeConfiguration, or the result of cls(response) + :return: DscNodeConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscNodeConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeConfiguration] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_configuration_name=node_configuration_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -340,10 +316,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -351,39 +326,42 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscNodeConfiguration', pipeline_response) + deserialized = self._deserialize("DscNodeConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore def _create_or_update_initial( self, resource_group_name: str, automation_account_name: str, node_configuration_name: str, - parameters: _models.DscNodeConfigurationCreateOrUpdateParameters, + parameters: Union[_models.DscNodeConfigurationCreateOrUpdateParameters, IO], **kwargs: Any ) -> Optional[_models.DscNodeConfiguration]: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.DscNodeConfiguration]] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.DscNodeConfiguration]] - _json = self._serialize.body(parameters, 'DscNodeConfigurationCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "DscNodeConfigurationCreateOrUpdateParameters") - request = build_create_or_update_request_initial( + request = build_create_or_update_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_configuration_name=node_configuration_name, @@ -391,7 +369,8 @@ def _create_or_update_initial( api_version=api_version, content_type=content_type, json=_json, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -399,50 +378,51 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) deserialized = None if response.status_code == 201: - deserialized = self._deserialize('DscNodeConfiguration', pipeline_response) + deserialized = self._deserialize("DscNodeConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore - + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore - @distributed_trace + @overload def begin_create_or_update( self, resource_group_name: str, automation_account_name: str, node_configuration_name: str, parameters: _models.DscNodeConfigurationCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any - ) -> LROPoller[_models.DscNodeConfiguration]: + ) -> LROPoller[None]: """Create the node configuration identified by node configuration name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_configuration_name: The Dsc node configuration name. + :param node_configuration_name: The Dsc node configuration name. Required. :type node_configuration_name: str - :param parameters: The create or update parameters for configuration. + :param parameters: The create or update parameters for configuration. Required. :type parameters: ~azure.mgmt.automation.models.DscNodeConfigurationCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -454,20 +434,93 @@ def begin_create_or_update( :return: An instance of LROPoller that returns either DscNodeConfiguration or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.DscNodeConfiguration] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + node_configuration_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[None]: + """Create the node configuration identified by node configuration name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param node_configuration_name: The Dsc node configuration name. Required. + :type node_configuration_name: str + :param parameters: The create or update parameters for configuration. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either DscNodeConfiguration or the result of + cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.DscNodeConfiguration] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + node_configuration_name: str, + parameters: Union[_models.DscNodeConfigurationCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> LROPoller[None]: + """Create the node configuration identified by node configuration name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param node_configuration_name: The Dsc node configuration name. Required. + :type node_configuration_name: str + :param parameters: The create or update parameters for configuration. Is either a model type or + a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.DscNodeConfigurationCreateOrUpdateParameters or + IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either DscNodeConfiguration or the result of + cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.DscNodeConfiguration] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeConfiguration] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -476,39 +529,35 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('DscNodeConfiguration', pipeline_response) + deserialized = self._deserialize("DscNodeConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations/{nodeConfigurationName}"} # type: ignore @distributed_trace def list_by_automation_account( @@ -520,12 +569,12 @@ def list_by_automation_account( top: Optional[int] = None, inlinecount: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.DscNodeConfigurationListResult]: + ) -> Iterable["_models.DscNodeConfiguration"]: """Retrieve a list of dsc node configurations. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str @@ -535,39 +584,34 @@ def list_by_automation_account( :type top: int :param inlinecount: Return total rows. Default value is None. :type inlinecount: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscNodeConfigurationListResult or the result of + :return: An iterator like instance of either DscNodeConfiguration or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscNodeConfigurationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscNodeConfiguration] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeConfigurationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeConfigurationListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, skip=skip, top=top, inlinecount=inlinecount, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -575,20 +619,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - skip=skip, - top=top, - inlinecount=inlinecount, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -604,10 +635,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -618,8 +647,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodeConfigurations"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_node_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_node_operations.py index 85afb5bd8ea5..916631798c0c 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_node_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_dsc_node_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,136 +24,119 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - resource_group_name: str, - automation_account_name: str, - node_id: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, node_id: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeId": _SERIALIZER.url("node_id", node_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeId": _SERIALIZER.url("node_id", node_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - node_id: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, node_id: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeId": _SERIALIZER.url("node_id", node_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeId": _SERIALIZER.url("node_id", node_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - node_id: str, - subscription_id: str, - *, - json: Optional[_models.DscNodeUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, node_id: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeId": _SERIALIZER.url("node_id", node_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeId": _SERIALIZER.url("node_id", node_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -166,40 +153,40 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") if skip is not None: - _params['$skip'] = _SERIALIZER.query("skip", skip, 'int') + _params["$skip"] = _SERIALIZER.query("skip", skip, "int") if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'int') + _params["$top"] = _SERIALIZER.query("top", top, "int") if inlinecount is not None: - _params['$inlinecount'] = _SERIALIZER.query("inlinecount", inlinecount, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$inlinecount"] = _SERIALIZER.query("inlinecount", inlinecount, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class DscNodeOperations: """ @@ -220,50 +207,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - node_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_id: str, **kwargs: Any ) -> None: """Delete the dsc node identified by node id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The node id. + :param node_id: The node id. Required. :type node_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_id=node_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -271,10 +247,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -285,52 +260,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - node_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_id: str, **kwargs: Any ) -> _models.DscNode: """Retrieve the dsc node identified by node id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The node id. + :param node_id: The node id. Required. :type node_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscNode, or the result of cls(response) + :return: DscNode or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscNode - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNode] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNode] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_id=node_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -338,10 +302,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -349,56 +312,120 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscNode', pipeline_response) + deserialized = self._deserialize("DscNode", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, node_id: str, dsc_node_update_parameters: _models.DscNodeUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.DscNode: """Update the dsc node. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: Parameters supplied to the update dsc node. + :param node_id: Parameters supplied to the update dsc node. Required. :type node_id: str - :param dsc_node_update_parameters: Parameters supplied to the update dsc node. + :param dsc_node_update_parameters: Parameters supplied to the update dsc node. Required. :type dsc_node_update_parameters: ~azure.mgmt.automation.models.DscNodeUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscNode or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscNode + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + node_id: str, + dsc_node_update_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.DscNode: + """Update the dsc node. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param node_id: Parameters supplied to the update dsc node. Required. + :type node_id: str + :param dsc_node_update_parameters: Parameters supplied to the update dsc node. Required. + :type dsc_node_update_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscNode, or the result of cls(response) + :return: DscNode or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscNode - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + node_id: str, + dsc_node_update_parameters: Union[_models.DscNodeUpdateParameters, IO], + **kwargs: Any + ) -> _models.DscNode: + """Update the dsc node. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param node_id: Parameters supplied to the update dsc node. Required. + :type node_id: str + :param dsc_node_update_parameters: Parameters supplied to the update dsc node. Is either a + model type or a IO type. Required. + :type dsc_node_update_parameters: ~azure.mgmt.automation.models.DscNodeUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: DscNode or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.DscNode + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNode] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNode] - _json = self._serialize.body(dsc_node_update_parameters, 'DscNodeUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(dsc_node_update_parameters, (IO, bytes)): + _content = dsc_node_update_parameters + else: + _json = self._serialize.body(dsc_node_update_parameters, "DscNodeUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -408,7 +435,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -416,10 +444,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -427,15 +454,14 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscNode', pipeline_response) + deserialized = self._deserialize("DscNode", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}"} # type: ignore @distributed_trace def list_by_automation_account( @@ -447,12 +473,12 @@ def list_by_automation_account( top: Optional[int] = None, inlinecount: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.DscNodeListResult]: + ) -> Iterable["_models.DscNode"]: """Retrieve a list of dsc nodes. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str @@ -462,37 +488,33 @@ def list_by_automation_account( :type top: int :param inlinecount: Return total rows. Default value is None. :type inlinecount: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscNodeListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscNodeListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either DscNode or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscNode] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, skip=skip, top=top, inlinecount=inlinecount, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -500,20 +522,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - skip=skip, - top=top, - inlinecount=inlinecount, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -529,10 +538,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -543,8 +550,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_fields_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_fields_operations.py index c8d773cbb0c4..1f7a4308aabc 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_fields_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_fields_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +24,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_by_type_request( resource_group_name: str, automation_account_name: str, @@ -38,34 +45,34 @@ def build_list_by_type_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/types/{typeName}/fields") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/types/{typeName}/fields", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "moduleName": _SERIALIZER.url("module_name", module_name, 'str'), - "typeName": _SERIALIZER.url("type_name", type_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "moduleName": _SERIALIZER.url("module_name", module_name, "str"), + "typeName": _SERIALIZER.url("type_name", type_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class FieldsOperations: """ @@ -86,47 +93,37 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_type( - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - type_name: str, - **kwargs: Any - ) -> Iterable[_models.TypeFieldListResult]: + self, resource_group_name: str, automation_account_name: str, module_name: str, type_name: str, **kwargs: Any + ) -> Iterable["_models.TypeField"]: """Retrieve a list of fields of a given type identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param type_name: The name of type. + :param type_name: The name of type. Required. :type type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either TypeFieldListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.TypeFieldListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either TypeField or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.TypeField] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.TypeFieldListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.TypeFieldListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_type_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -134,7 +131,7 @@ def prepare_request(next_link=None): type_name=type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_type.metadata['url'], + template_url=self.list_by_type.metadata["url"], headers=_headers, params=_params, ) @@ -142,18 +139,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_type_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - module_name=module_name, - type_name=type_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -169,10 +155,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -183,8 +167,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_type.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/types/{typeName}/fields"} # type: ignore + list_by_type.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/types/{typeName}/fields"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_hybrid_runbook_worker_group_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_hybrid_runbook_worker_group_operations.py index 3487c7d855df..5aedc2424b57 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_hybrid_runbook_worker_group_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_hybrid_runbook_worker_group_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +24,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( resource_group_name: str, automation_account_name: str, @@ -37,33 +44,34 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( @@ -76,33 +84,34 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_request( @@ -110,46 +119,42 @@ def build_create_request( automation_account_name: str, hybrid_runbook_worker_group_name: str, subscription_id: str, - *, - json: Optional[_models.HybridRunbookWorkerGroupCreateOrUpdateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( @@ -157,46 +162,42 @@ def build_update_request( automation_account_name: str, hybrid_runbook_worker_group_name: str, subscription_id: str, - *, - json: Optional[_models.HybridRunbookWorkerGroupCreateOrUpdateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -210,34 +211,34 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class HybridRunbookWorkerGroupOperations: """ @@ -258,7 +259,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements self, @@ -269,39 +269,33 @@ def delete( # pylint: disable=inconsistent-return-statements ) -> None: """Delete a hybrid runbook worker group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, hybrid_runbook_worker_group_name=hybrid_runbook_worker_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -309,10 +303,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -323,8 +316,7 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore @distributed_trace def get( @@ -336,39 +328,33 @@ def get( ) -> _models.HybridRunbookWorkerGroup: """Retrieve a hybrid runbook worker group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorkerGroup, or the result of cls(response) + :return: HybridRunbookWorkerGroup or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkerGroup] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkerGroup] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, hybrid_runbook_worker_group_name=hybrid_runbook_worker_group_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -376,10 +362,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -387,58 +372,128 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorkerGroup', pipeline_response) + deserialized = self._deserialize("HybridRunbookWorkerGroup", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore - - @distributed_trace + @overload def create( self, resource_group_name: str, automation_account_name: str, hybrid_runbook_worker_group_name: str, hybrid_runbook_worker_group_creation_parameters: _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.HybridRunbookWorkerGroup: """Create a hybrid runbook worker group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str :param hybrid_runbook_worker_group_creation_parameters: The create or update parameters for - hybrid runbook worker group. + hybrid runbook worker group. Required. :type hybrid_runbook_worker_group_creation_parameters: ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorkerGroup, or the result of cls(response) + :return: HybridRunbookWorkerGroup or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def create( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_group_creation_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.HybridRunbookWorkerGroup: + """Create a hybrid runbook worker group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_group_creation_parameters: The create or update parameters for + hybrid runbook worker group. Required. + :type hybrid_runbook_worker_group_creation_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorkerGroup or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_group_creation_parameters: Union[ + _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, IO + ], + **kwargs: Any + ) -> _models.HybridRunbookWorkerGroup: + """Create a hybrid runbook worker group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_group_creation_parameters: The create or update parameters for + hybrid runbook worker group. Is either a model type or a IO type. Required. + :type hybrid_runbook_worker_group_creation_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorkerGroup or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkerGroup] - - _json = self._serialize.body(hybrid_runbook_worker_group_creation_parameters, 'HybridRunbookWorkerGroupCreateOrUpdateParameters') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkerGroup] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(hybrid_runbook_worker_group_creation_parameters, (IO, bytes)): + _content = hybrid_runbook_worker_group_creation_parameters + else: + _json = self._serialize.body( + hybrid_runbook_worker_group_creation_parameters, "HybridRunbookWorkerGroupCreateOrUpdateParameters" + ) request = build_create_request( resource_group_name=resource_group_name, @@ -448,7 +503,8 @@ def create( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -456,26 +512,91 @@ def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response - if response.status_code not in [200]: + if response.status_code not in [200, 201]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorkerGroup', pipeline_response) + if response.status_code == 200: + deserialized = self._deserialize("HybridRunbookWorkerGroup", pipeline_response) + + if response.status_code == 201: + deserialized = self._deserialize("HybridRunbookWorkerGroup", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_group_updation_parameters: _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.HybridRunbookWorkerGroup: + """Update a hybrid runbook worker group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_group_updation_parameters: The hybrid runbook worker group. + Required. + :type hybrid_runbook_worker_group_updation_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorkerGroup or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_group_updation_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.HybridRunbookWorkerGroup: + """Update a hybrid runbook worker group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_group_updation_parameters: The hybrid runbook worker group. + Required. + :type hybrid_runbook_worker_group_updation_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorkerGroup or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup + :raises ~azure.core.exceptions.HttpResponseError: + """ @distributed_trace def update( @@ -483,41 +604,50 @@ def update( resource_group_name: str, automation_account_name: str, hybrid_runbook_worker_group_name: str, - parameters: _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, + hybrid_runbook_worker_group_updation_parameters: Union[ + _models.HybridRunbookWorkerGroupCreateOrUpdateParameters, IO + ], **kwargs: Any ) -> _models.HybridRunbookWorkerGroup: """Update a hybrid runbook worker group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param parameters: The hybrid runbook worker group. - :type parameters: - ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :param hybrid_runbook_worker_group_updation_parameters: The hybrid runbook worker group. Is + either a model type or a IO type. Required. + :type hybrid_runbook_worker_group_updation_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerGroupCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorkerGroup, or the result of cls(response) + :return: HybridRunbookWorkerGroup or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorkerGroup - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkerGroup] - - _json = self._serialize.body(parameters, 'HybridRunbookWorkerGroupCreateOrUpdateParameters') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkerGroup] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(hybrid_runbook_worker_group_updation_parameters, (IO, bytes)): + _content = hybrid_runbook_worker_group_updation_parameters + else: + _json = self._serialize.body( + hybrid_runbook_worker_group_updation_parameters, "HybridRunbookWorkerGroupCreateOrUpdateParameters" + ) request = build_update_request( resource_group_name=resource_group_name, @@ -527,7 +657,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -535,10 +666,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -546,62 +676,52 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorkerGroup', pipeline_response) + deserialized = self._deserialize("HybridRunbookWorkerGroup", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> Iterable[_models.HybridRunbookWorkerGroupsListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.HybridRunbookWorkerGroup"]: """Retrieve a list of hybrid runbook worker groups. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either HybridRunbookWorkerGroupsListResult or the result - of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.HybridRunbookWorkerGroupsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either HybridRunbookWorkerGroup or the result of + cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.HybridRunbookWorkerGroup] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkerGroupsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkerGroupsListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -609,17 +729,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -635,10 +745,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -649,8 +757,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_hybrid_runbook_workers_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_hybrid_runbook_workers_operations.py index 5bf5d7bb5278..b0bfc5f74c89 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_hybrid_runbook_workers_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_hybrid_runbook_workers_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +24,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( resource_group_name: str, automation_account_name: str, @@ -38,34 +45,35 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "hybridRunbookWorkerId": _SERIALIZER.url("hybrid_runbook_worker_id", hybrid_runbook_worker_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "hybridRunbookWorkerId": _SERIALIZER.url("hybrid_runbook_worker_id", hybrid_runbook_worker_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( @@ -79,34 +87,35 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "hybridRunbookWorkerId": _SERIALIZER.url("hybrid_runbook_worker_id", hybrid_runbook_worker_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "hybridRunbookWorkerId": _SERIALIZER.url("hybrid_runbook_worker_id", hybrid_runbook_worker_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_request( @@ -115,47 +124,43 @@ def build_create_request( hybrid_runbook_worker_group_name: str, hybrid_runbook_worker_id: str, subscription_id: str, - *, - json: Optional[_models.HybridRunbookWorkerCreateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "hybridRunbookWorkerId": _SERIALIZER.url("hybrid_runbook_worker_id", hybrid_runbook_worker_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "hybridRunbookWorkerId": _SERIALIZER.url("hybrid_runbook_worker_id", hybrid_runbook_worker_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_move_request( @@ -164,47 +169,43 @@ def build_move_request( hybrid_runbook_worker_group_name: str, hybrid_runbook_worker_id: str, subscription_id: str, - *, - json: Optional[_models.HybridRunbookWorkerMoveParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}/move") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}/move", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "hybridRunbookWorkerId": _SERIALIZER.url("hybrid_runbook_worker_id", hybrid_runbook_worker_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "hybridRunbookWorkerId": _SERIALIZER.url("hybrid_runbook_worker_id", hybrid_runbook_worker_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_hybrid_runbook_worker_group_request( @@ -219,35 +220,37 @@ def build_list_by_hybrid_runbook_worker_group_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "hybridRunbookWorkerGroupName": _SERIALIZER.url("hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "hybridRunbookWorkerGroupName": _SERIALIZER.url( + "hybrid_runbook_worker_group_name", hybrid_runbook_worker_group_name, "str" + ), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class HybridRunbookWorkersOperations: """ @@ -268,7 +271,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements self, @@ -280,34 +282,28 @@ def delete( # pylint: disable=inconsistent-return-statements ) -> None: """Delete a hybrid runbook worker. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param hybrid_runbook_worker_id: The hybrid runbook worker id. + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. :type hybrid_runbook_worker_id: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -315,7 +311,7 @@ def delete( # pylint: disable=inconsistent-return-statements hybrid_runbook_worker_id=hybrid_runbook_worker_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -323,10 +319,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -337,8 +332,7 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore @distributed_trace def get( @@ -351,34 +345,28 @@ def get( ) -> _models.HybridRunbookWorker: """Retrieve a hybrid runbook worker. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param hybrid_runbook_worker_id: The hybrid runbook worker id. + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. :type hybrid_runbook_worker_id: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorker, or the result of cls(response) + :return: HybridRunbookWorker or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorker - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorker] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorker] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -386,7 +374,7 @@ def get( hybrid_runbook_worker_id=hybrid_runbook_worker_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -394,10 +382,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -405,17 +392,16 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorker', pipeline_response) + deserialized = self._deserialize("HybridRunbookWorker", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore - @distributed_trace + @overload def create( self, resource_group_name: str, @@ -423,43 +409,118 @@ def create( hybrid_runbook_worker_group_name: str, hybrid_runbook_worker_id: str, hybrid_runbook_worker_creation_parameters: _models.HybridRunbookWorkerCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.HybridRunbookWorker: """Create a hybrid runbook worker. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param hybrid_runbook_worker_id: The hybrid runbook worker id. + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. :type hybrid_runbook_worker_id: str :param hybrid_runbook_worker_creation_parameters: The create or update parameters for hybrid - runbook worker. + runbook worker. Required. :type hybrid_runbook_worker_creation_parameters: ~azure.mgmt.automation.models.HybridRunbookWorkerCreateParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorker or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorker + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_id: str, + hybrid_runbook_worker_creation_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.HybridRunbookWorker: + """Create a hybrid runbook worker. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. + :type hybrid_runbook_worker_id: str + :param hybrid_runbook_worker_creation_parameters: The create or update parameters for hybrid + runbook worker. Required. + :type hybrid_runbook_worker_creation_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: HybridRunbookWorker, or the result of cls(response) + :return: HybridRunbookWorker or the result of cls(response) :rtype: ~azure.mgmt.automation.models.HybridRunbookWorker - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def create( + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_id: str, + hybrid_runbook_worker_creation_parameters: Union[_models.HybridRunbookWorkerCreateParameters, IO], + **kwargs: Any + ) -> _models.HybridRunbookWorker: + """Create a hybrid runbook worker. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. + :type hybrid_runbook_worker_id: str + :param hybrid_runbook_worker_creation_parameters: The create or update parameters for hybrid + runbook worker. Is either a model type or a IO type. Required. + :type hybrid_runbook_worker_creation_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: HybridRunbookWorker or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.HybridRunbookWorker + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorker] - - _json = self._serialize.body(hybrid_runbook_worker_creation_parameters, 'HybridRunbookWorkerCreateParameters') + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorker] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(hybrid_runbook_worker_creation_parameters, (IO, bytes)): + _content = hybrid_runbook_worker_creation_parameters + else: + _json = self._serialize.body( + hybrid_runbook_worker_creation_parameters, "HybridRunbookWorkerCreateParameters" + ) request = build_create_request( resource_group_name=resource_group_name, @@ -470,7 +531,8 @@ def create( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -478,28 +540,30 @@ def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response - if response.status_code not in [200]: + if response.status_code not in [200, 201]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('HybridRunbookWorker', pipeline_response) + if response.status_code == 200: + deserialized = self._deserialize("HybridRunbookWorker", pipeline_response) + + if response.status_code == 201: + deserialized = self._deserialize("HybridRunbookWorker", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}"} # type: ignore - - @distributed_trace + @overload def move( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, @@ -507,42 +571,116 @@ def move( # pylint: disable=inconsistent-return-statements hybrid_runbook_worker_group_name: str, hybrid_runbook_worker_id: str, hybrid_runbook_worker_move_parameters: _models.HybridRunbookWorkerMoveParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> None: """Move a hybrid worker to a different group. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str - :param hybrid_runbook_worker_id: The hybrid runbook worker id. + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. :type hybrid_runbook_worker_id: str :param hybrid_runbook_worker_move_parameters: The hybrid runbook worker move parameters. + Required. :type hybrid_runbook_worker_move_parameters: ~azure.mgmt.automation.models.HybridRunbookWorkerMoveParameters - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def move( # pylint: disable=inconsistent-return-statements + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_id: str, + hybrid_runbook_worker_move_parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Move a hybrid worker to a different group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. + :type hybrid_runbook_worker_id: str + :param hybrid_runbook_worker_move_parameters: The hybrid runbook worker move parameters. + Required. + :type hybrid_runbook_worker_move_parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def move( # pylint: disable=inconsistent-return-statements + self, + resource_group_name: str, + automation_account_name: str, + hybrid_runbook_worker_group_name: str, + hybrid_runbook_worker_id: str, + hybrid_runbook_worker_move_parameters: Union[_models.HybridRunbookWorkerMoveParameters, IO], + **kwargs: Any + ) -> None: + """Move a hybrid worker to a different group. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. + :type hybrid_runbook_worker_group_name: str + :param hybrid_runbook_worker_id: The hybrid runbook worker id. Required. + :type hybrid_runbook_worker_id: str + :param hybrid_runbook_worker_move_parameters: The hybrid runbook worker move parameters. Is + either a model type or a IO type. Required. + :type hybrid_runbook_worker_move_parameters: + ~azure.mgmt.automation.models.HybridRunbookWorkerMoveParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] - _json = self._serialize.body(hybrid_runbook_worker_move_parameters, 'HybridRunbookWorkerMoveParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(hybrid_runbook_worker_move_parameters, (IO, bytes)): + _content = hybrid_runbook_worker_move_parameters + else: + _json = self._serialize.body(hybrid_runbook_worker_move_parameters, "HybridRunbookWorkerMoveParameters") request = build_move_request( resource_group_name=resource_group_name, @@ -553,7 +691,8 @@ def move( # pylint: disable=inconsistent-return-statements api_version=api_version, content_type=content_type, json=_json, - template_url=self.move.metadata['url'], + content=_content, + template_url=self.move.metadata["url"], headers=_headers, params=_params, ) @@ -561,10 +700,9 @@ def move( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -575,8 +713,7 @@ def move( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - move.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}/move"} # type: ignore - + move.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers/{hybridRunbookWorkerId}/move"} # type: ignore @distributed_trace def list_by_hybrid_runbook_worker_group( @@ -586,48 +723,42 @@ def list_by_hybrid_runbook_worker_group( hybrid_runbook_worker_group_name: str, filter: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.HybridRunbookWorkersListResult]: + ) -> Iterable["_models.HybridRunbookWorker"]: """Retrieve a list of hybrid runbook workers. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. + :param hybrid_runbook_worker_group_name: The hybrid runbook worker group name. Required. :type hybrid_runbook_worker_group_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either HybridRunbookWorkersListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.HybridRunbookWorkersListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either HybridRunbookWorker or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.HybridRunbookWorker] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.HybridRunbookWorkersListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.HybridRunbookWorkersListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_hybrid_runbook_worker_group_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, hybrid_runbook_worker_group_name=hybrid_runbook_worker_group_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_hybrid_runbook_worker_group.metadata['url'], + api_version=api_version, + template_url=self.list_by_hybrid_runbook_worker_group.metadata["url"], headers=_headers, params=_params, ) @@ -635,18 +766,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_hybrid_runbook_worker_group_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - hybrid_runbook_worker_group_name=hybrid_runbook_worker_group_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -662,10 +782,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -676,8 +794,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_hybrid_runbook_worker_group.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers"} # type: ignore + list_by_hybrid_runbook_worker_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/hybridRunbookWorkerGroups/{hybridRunbookWorkerGroupName}/hybridRunbookWorkers"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_operations.py index c1adbf23cf56..2f388693b4eb 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,18 +24,21 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_output_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, job_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -39,42 +46,41 @@ def build_get_output_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "text/plain") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "text/plain") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/output") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/output", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_runbook_content_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, job_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -82,42 +88,41 @@ def build_get_runbook_content_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "text/powershell") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "text/powershell") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/runbookContent") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/runbookContent", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_suspend_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, job_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -125,35 +130,34 @@ def build_suspend_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/suspend") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/suspend", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_stop_request( @@ -168,42 +172,41 @@ def build_stop_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/stop") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/stop", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, job_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -211,85 +214,79 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, job_name: str, + subscription_id: str, *, - json: Optional[_models.JobCreateParameters] = None, - content: Any = None, client_request_id: Optional[str] = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -304,36 +301,35 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_resume_request( @@ -348,35 +344,35 @@ def build_resume_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/resume") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/resume", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class JobOperations: """ @@ -397,7 +393,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def get_output( self, @@ -409,42 +404,36 @@ def get_output( ) -> str: """Retrieve the job output identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The name of the job to be created. + :param job_name: The name of the job to be created. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: str, or the result of cls(response) + :return: str or the result of cls(response) :rtype: str - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[str] - request = build_get_output_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_output.metadata['url'], + api_version=api_version, + template_url=self.get_output.metadata["url"], headers=_headers, params=_params, ) @@ -452,25 +441,23 @@ def get_output( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('str', pipeline_response) + deserialized = self._deserialize("str", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_output.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/output"} # type: ignore - + get_output.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/output"} # type: ignore @distributed_trace def get_runbook_content( @@ -483,42 +470,36 @@ def get_runbook_content( ) -> str: """Retrieve the runbook content of the job identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: str, or the result of cls(response) + :return: str or the result of cls(response) :rtype: str - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[str] - request = build_get_runbook_content_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_runbook_content.metadata['url'], + api_version=api_version, + template_url=self.get_runbook_content.metadata["url"], headers=_headers, params=_params, ) @@ -526,25 +507,23 @@ def get_runbook_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('str', pipeline_response) + deserialized = self._deserialize("str", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_runbook_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/runbookContent"} # type: ignore - + get_runbook_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/runbookContent"} # type: ignore @distributed_trace def suspend( # pylint: disable=inconsistent-return-statements @@ -557,42 +536,36 @@ def suspend( # pylint: disable=inconsistent-return-statements ) -> None: """Suspend the job identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_suspend_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.suspend.metadata['url'], + api_version=api_version, + template_url=self.suspend.metadata["url"], headers=_headers, params=_params, ) @@ -600,10 +573,9 @@ def suspend( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -614,8 +586,7 @@ def suspend( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - suspend.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/suspend"} # type: ignore - + suspend.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/suspend"} # type: ignore @distributed_trace def stop( # pylint: disable=inconsistent-return-statements @@ -628,42 +599,36 @@ def stop( # pylint: disable=inconsistent-return-statements ) -> None: """Stop the job identified by jobName. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_stop_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, subscription_id=self._config.subscription_id, - api_version=api_version, client_request_id=client_request_id, - template_url=self.stop.metadata['url'], + api_version=api_version, + template_url=self.stop.metadata["url"], headers=_headers, params=_params, ) @@ -671,10 +636,9 @@ def stop( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -685,8 +649,7 @@ def stop( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - stop.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/stop"} # type: ignore - + stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/stop"} # type: ignore @distributed_trace def get( @@ -699,42 +662,36 @@ def get( ) -> _models.Job: """Retrieve the job identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Job, or the result of cls(response) + :return: Job or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Job - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Job] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Job] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get.metadata['url'], + api_version=api_version, + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -742,10 +699,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -753,17 +709,16 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Job', pipeline_response) + deserialized = self._deserialize("Job", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}"} # type: ignore - @distributed_trace + @overload def create( self, resource_group_name: str, @@ -771,52 +726,124 @@ def create( job_name: str, parameters: _models.JobCreateParameters, client_request_id: Optional[str] = None, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Job: """Create a job of the runbook. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str - :param parameters: The parameters supplied to the create job operation. + :param parameters: The parameters supplied to the create job operation. Required. :type parameters: ~azure.mgmt.automation.models.JobCreateParameters :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Job, or the result of cls(response) + :return: Job or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Job - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def create( + self, + resource_group_name: str, + automation_account_name: str, + job_name: str, + parameters: IO, + client_request_id: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Job: + """Create a job of the runbook. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param job_name: The job name. Required. + :type job_name: str + :param parameters: The parameters supplied to the create job operation. Required. + :type parameters: IO + :param client_request_id: Identifies this specific client request. Default value is None. + :type client_request_id: str + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Job or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Job + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create( + self, + resource_group_name: str, + automation_account_name: str, + job_name: str, + parameters: Union[_models.JobCreateParameters, IO], + client_request_id: Optional[str] = None, + **kwargs: Any + ) -> _models.Job: + """Create a job of the runbook. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param job_name: The job name. Required. + :type job_name: str + :param parameters: The parameters supplied to the create job operation. Is either a model type + or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.JobCreateParameters or IO + :param client_request_id: Identifies this specific client request. Default value is None. + :type client_request_id: str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Job or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Job + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Job] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Job] - _json = self._serialize.body(parameters, 'JobCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "JobCreateParameters") request = build_create_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, + subscription_id=self._config.subscription_id, + client_request_id=client_request_id, api_version=api_version, content_type=content_type, json=_json, - client_request_id=client_request_id, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -824,10 +851,9 @@ def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -835,15 +861,14 @@ def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Job', pipeline_response) + deserialized = self._deserialize("Job", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}"} # type: ignore @distributed_trace def list_by_automation_account( @@ -853,46 +878,42 @@ def list_by_automation_account( filter: Optional[str] = None, client_request_id: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.JobListResultV2]: + ) -> Iterable["_models.JobCollectionItem"]: """Retrieve a list of jobs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either JobListResultV2 or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.JobListResultV2] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either JobCollectionItem or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.JobCollectionItem] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobListResultV2] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobListResultV2] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, client_request_id=client_request_id, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -900,18 +921,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - client_request_id=client_request_id, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -927,10 +937,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -941,11 +949,9 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs"} # type: ignore @distributed_trace def resume( # pylint: disable=inconsistent-return-statements @@ -958,42 +964,36 @@ def resume( # pylint: disable=inconsistent-return-statements ) -> None: """Resume the job identified by jobName. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_resume_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, subscription_id=self._config.subscription_id, - api_version=api_version, client_request_id=client_request_id, - template_url=self.resume.metadata['url'], + api_version=api_version, + template_url=self.resume.metadata["url"], headers=_headers, params=_params, ) @@ -1001,10 +1001,9 @@ def resume( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -1015,5 +1014,4 @@ def resume( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - resume.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/resume"} # type: ignore - + resume.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/resume"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_schedule_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_schedule_operations.py index 37d503573f7b..02856735bf01 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_schedule_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_schedule_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,136 +24,119 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - resource_group_name: str, - automation_account_name: str, - job_schedule_id: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, job_schedule_id: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobScheduleId": _SERIALIZER.url("job_schedule_id", job_schedule_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobScheduleId": _SERIALIZER.url("job_schedule_id", job_schedule_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - job_schedule_id: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, job_schedule_id: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobScheduleId": _SERIALIZER.url("job_schedule_id", job_schedule_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobScheduleId": _SERIALIZER.url("job_schedule_id", job_schedule_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_request( - resource_group_name: str, - automation_account_name: str, - job_schedule_id: str, - subscription_id: str, - *, - json: Optional[_models.JobScheduleCreateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, job_schedule_id: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobScheduleId": _SERIALIZER.url("job_schedule_id", job_schedule_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobScheduleId": _SERIALIZER.url("job_schedule_id", job_schedule_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -163,34 +150,34 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class JobScheduleOperations: """ @@ -211,50 +198,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - job_schedule_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, job_schedule_id: str, **kwargs: Any ) -> None: """Delete the job schedule identified by job schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_schedule_id: The job schedule name. + :param job_schedule_id: The job schedule name. Required. :type job_schedule_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_schedule_id=job_schedule_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -262,10 +238,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -276,52 +251,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - job_schedule_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, job_schedule_id: str, **kwargs: Any ) -> _models.JobSchedule: """Retrieve the job schedule identified by job schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_schedule_id: The job schedule name. + :param job_schedule_id: The job schedule name. Required. :type job_schedule_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobSchedule, or the result of cls(response) + :return: JobSchedule or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobSchedule - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobSchedule] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobSchedule] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_schedule_id=job_schedule_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -329,10 +293,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -340,56 +303,120 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobSchedule', pipeline_response) + deserialized = self._deserialize("JobSchedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore - @distributed_trace + @overload def create( self, resource_group_name: str, automation_account_name: str, job_schedule_id: str, parameters: _models.JobScheduleCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.JobSchedule: """Create a job schedule. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_schedule_id: The job schedule name. + :param job_schedule_id: The job schedule name. Required. :type job_schedule_id: str - :param parameters: The parameters supplied to the create job schedule operation. + :param parameters: The parameters supplied to the create job schedule operation. Required. :type parameters: ~azure.mgmt.automation.models.JobScheduleCreateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobSchedule, or the result of cls(response) + :return: JobSchedule or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobSchedule - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def create( + self, + resource_group_name: str, + automation_account_name: str, + job_schedule_id: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.JobSchedule: + """Create a job schedule. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param job_schedule_id: The job schedule name. Required. + :type job_schedule_id: str + :param parameters: The parameters supplied to the create job schedule operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: JobSchedule or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.JobSchedule + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create( + self, + resource_group_name: str, + automation_account_name: str, + job_schedule_id: str, + parameters: Union[_models.JobScheduleCreateParameters, IO], + **kwargs: Any + ) -> _models.JobSchedule: + """Create a job schedule. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param job_schedule_id: The job schedule name. Required. + :type job_schedule_id: str + :param parameters: The parameters supplied to the create job schedule operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.JobScheduleCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: JobSchedule or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.JobSchedule + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobSchedule] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobSchedule] - _json = self._serialize.body(parameters, 'JobScheduleCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "JobScheduleCreateParameters") request = build_create_request( resource_group_name=resource_group_name, @@ -399,7 +426,8 @@ def create( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -407,10 +435,9 @@ def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -418,61 +445,51 @@ def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobSchedule', pipeline_response) + deserialized = self._deserialize("JobSchedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules/{jobScheduleId}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> Iterable[_models.JobScheduleListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.JobSchedule"]: """Retrieve a list of job schedules. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either JobScheduleListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.JobScheduleListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either JobSchedule or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.JobSchedule] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobScheduleListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobScheduleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -480,17 +497,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -506,10 +513,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -520,8 +525,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobSchedules"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_stream_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_stream_operations.py index 2772dc92ea4b..cf082a0b487c 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_stream_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_job_stream_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,19 +24,22 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, job_name: str, job_stream_id: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -40,36 +47,35 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams/{jobStreamId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams/{jobStreamId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), - "jobStreamId": _SERIALIZER.url("job_stream_id", job_stream_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), + "jobStreamId": _SERIALIZER.url("job_stream_id", job_stream_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_job_request( @@ -85,37 +91,37 @@ def build_list_by_job_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "jobName": _SERIALIZER.url("job_name", job_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "jobName": _SERIALIZER.url("job_name", job_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class JobStreamOperations: """ @@ -136,7 +142,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def get( self, @@ -149,45 +154,39 @@ def get( ) -> _models.JobStream: """Retrieve the job stream identified by job stream id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str - :param job_stream_id: The job stream id. + :param job_stream_id: The job stream id. Required. :type job_stream_id: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobStream, or the result of cls(response) + :return: JobStream or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobStream - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStream] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStream] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, job_stream_id=job_stream_id, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get.metadata['url'], + api_version=api_version, + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -195,10 +194,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -206,15 +204,14 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobStream', pipeline_response) + deserialized = self._deserialize("JobStream", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams/{jobStreamId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams/{jobStreamId}"} # type: ignore @distributed_trace def list_by_job( @@ -225,49 +222,45 @@ def list_by_job( filter: Optional[str] = None, client_request_id: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.JobStreamListResult]: + ) -> Iterable["_models.JobStream"]: """Retrieve a list of jobs streams identified by job name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param job_name: The job name. + :param job_name: The job name. Required. :type job_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either JobStreamListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.JobStreamListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either JobStream or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.JobStream] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStreamListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStreamListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_job_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, job_name=job_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, client_request_id=client_request_id, - template_url=self.list_by_job.metadata['url'], + api_version=api_version, + template_url=self.list_by_job.metadata["url"], headers=_headers, params=_params, ) @@ -275,19 +268,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_job_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - job_name=job_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - client_request_id=client_request_id, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -303,10 +284,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -317,8 +296,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_job.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams"} # type: ignore + list_by_job.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/jobs/{jobName}/streams"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_keys_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_keys_operations.py index b60ee45d277b..e6dec84eb7d6 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_keys_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_keys_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +23,48 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/listKeys") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/listKeys", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class KeysOperations: """ @@ -81,46 +85,36 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, **kwargs: Any ) -> _models.KeyListResult: """Retrieve the automation keys for an account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: KeyListResult, or the result of cls(response) + :return: KeyListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.KeyListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.KeyListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.KeyListResult] - request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -128,10 +122,9 @@ def list_by_automation_account( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -139,12 +132,11 @@ def list_by_automation_account( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('KeyListResult', pipeline_response) + deserialized = self._deserialize("KeyListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/listKeys"} # type: ignore - + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/listKeys"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_linked_workspace_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_linked_workspace_operations.py index 6d128e5f0c1f..fb2a22a81c90 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_linked_workspace_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_linked_workspace_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,48 +23,48 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/linkedWorkspace") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/linkedWorkspace", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class LinkedWorkspaceOperations: """ @@ -81,46 +85,34 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace - def get( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> _models.LinkedWorkspace: + def get(self, resource_group_name: str, automation_account_name: str, **kwargs: Any) -> _models.LinkedWorkspace: """Retrieve the linked workspace for the account id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: LinkedWorkspace, or the result of cls(response) + :return: LinkedWorkspace or the result of cls(response) :rtype: ~azure.mgmt.automation.models.LinkedWorkspace - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.LinkedWorkspace] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.LinkedWorkspace] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -128,10 +120,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -139,12 +130,11 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('LinkedWorkspace', pipeline_response) + deserialized = self._deserialize("LinkedWorkspace", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/linkedWorkspace"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/linkedWorkspace"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_module_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_module_operations.py index 3389c4f558b8..d1a9362b4ee6 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_module_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_module_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,220 +24,190 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - resource_group_name: str, - automation_account_name: str, - module_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, module_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "moduleName": _SERIALIZER.url("module_name", module_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "moduleName": _SERIALIZER.url("module_name", module_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - module_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, module_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "moduleName": _SERIALIZER.url("module_name", module_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "moduleName": _SERIALIZER.url("module_name", module_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - module_name: str, - subscription_id: str, - *, - json: Optional[_models.ModuleCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, module_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "moduleName": _SERIALIZER.url("module_name", module_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "moduleName": _SERIALIZER.url("module_name", module_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - module_name: str, - subscription_id: str, - *, - json: Optional[_models.ModuleUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, module_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "moduleName": _SERIALIZER.url("module_name", module_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "moduleName": _SERIALIZER.url("module_name", module_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ModuleOperations: """ @@ -254,50 +228,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, module_name: str, **kwargs: Any ) -> None: """Delete the module by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The module name. + :param module_name: The module name. Required. :type module_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, module_name=module_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +268,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -319,52 +281,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, module_name: str, **kwargs: Any ) -> _models.Module: """Retrieve the module identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The module name. + :param module_name: The module name. Required. :type module_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, module_name=module_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -372,10 +323,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -383,56 +333,120 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, module_name: str, parameters: _models.ModuleCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Module: """Create or Update the module identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param parameters: The create or update parameters for module. + :param parameters: The create or update parameters for module. Required. :type parameters: ~azure.mgmt.automation.models.ModuleCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + module_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Create or Update the module identified by module name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param module_name: The name of module. Required. + :type module_name: str + :param parameters: The create or update parameters for module. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + module_name: str, + parameters: Union[_models.ModuleCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Create or Update the module identified by module name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param module_name: The name of module. Required. + :type module_name: str + :param parameters: The create or update parameters for module. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.ModuleCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - _json = self._serialize.body(parameters, 'ModuleCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ModuleCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -442,7 +456,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -450,10 +465,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -462,59 +476,123 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, module_name: str, parameters: _models.ModuleUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Module: """Update the module identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param parameters: The update parameters for module. + :param parameters: The update parameters for module. Required. :type parameters: ~azure.mgmt.automation.models.ModuleUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + module_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Update the module identified by module name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param module_name: The name of module. Required. + :type module_name: str + :param parameters: The update parameters for module. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + module_name: str, + parameters: Union[_models.ModuleUpdateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Update the module identified by module name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param module_name: The name of module. Required. + :type module_name: str + :param parameters: The update parameters for module. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.automation.models.ModuleUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - _json = self._serialize.body(parameters, 'ModuleUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ModuleUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -524,7 +602,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -532,10 +611,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -543,56 +621,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.ModuleListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Module"]: """Retrieve a list of modules. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ModuleListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.ModuleListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Module or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Module] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ModuleListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ModuleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -600,16 +670,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -625,10 +686,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -639,8 +698,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_node_count_information_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_node_count_information_operations.py index 147472da69dc..3e0c2c225e66 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_node_count_information_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_node_count_information_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar, Union -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,13 +23,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_request( resource_group_name: str, automation_account_name: str, @@ -36,33 +43,33 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodecounts/{countType}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodecounts/{countType}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "countType": _SERIALIZER.url("count_type", count_type, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "countType": _SERIALIZER.url("count_type", count_type, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class NodeCountInformationOperations: """ @@ -83,7 +90,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def get( self, @@ -94,39 +100,34 @@ def get( ) -> _models.NodeCounts: """Retrieve counts for Dsc Nodes. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param count_type: The type of counts to retrieve. + :param count_type: The type of counts to retrieve. Known values are: "status" and + "nodeconfiguration". Required. :type count_type: str or ~azure.mgmt.automation.models.CountType - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: NodeCounts, or the result of cls(response) + :return: NodeCounts or the result of cls(response) :rtype: ~azure.mgmt.automation.models.NodeCounts - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.NodeCounts] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.NodeCounts] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, count_type=count_type, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -134,10 +135,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -145,12 +145,11 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('NodeCounts', pipeline_response) + deserialized = self._deserialize("NodeCounts", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodecounts/{countType}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodecounts/{countType}"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_node_reports_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_node_reports_operations.py index 72cde69f0d52..5dfd860f5726 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_node_reports_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_node_reports_operations.py @@ -6,11 +6,16 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- +import sys from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +25,21 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +if sys.version_info >= (3, 9): + from collections.abc import MutableMapping +else: + from typing import MutableMapping # type: ignore # pylint: disable=ungrouped-imports +JSON = MutableMapping[str, Any] # pylint: disable=unsubscriptable-object +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_by_node_request( resource_group_name: str, automation_account_name: str, @@ -39,35 +52,34 @@ def build_list_by_node_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeId": _SERIALIZER.url("node_id", node_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeId": _SERIALIZER.url("node_id", node_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( @@ -81,34 +93,33 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeId": _SERIALIZER.url("node_id", node_id, 'str'), - "reportId": _SERIALIZER.url("report_id", report_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeId": _SERIALIZER.url("node_id", node_id, "str"), + "reportId": _SERIALIZER.url("report_id", report_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_content_request( @@ -122,34 +133,34 @@ def build_get_content_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}/content") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}/content", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "nodeId": _SERIALIZER.url("node_id", node_id, 'str'), - "reportId": _SERIALIZER.url("report_id", report_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "nodeId": _SERIALIZER.url("node_id", node_id, "str"), + "reportId": _SERIALIZER.url("report_id", report_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class NodeReportsOperations: """ @@ -170,7 +181,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_node( self, @@ -179,47 +189,42 @@ def list_by_node( node_id: str, filter: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.DscNodeReportListResult]: + ) -> Iterable["_models.DscNodeReport"]: """Retrieve the Dsc node report list by node id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The parameters supplied to the list operation. + :param node_id: The parameters supplied to the list operation. Required. :type node_id: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either DscNodeReportListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscNodeReportListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either DscNodeReport or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.DscNodeReport] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeReportListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeReportListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_node_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, node_id=node_id, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_node.metadata['url'], + api_version=api_version, + template_url=self.list_by_node.metadata["url"], headers=_headers, params=_params, ) @@ -227,18 +232,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_node_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - node_id=node_id, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -254,10 +248,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -268,51 +260,38 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_node.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports"} # type: ignore + list_by_node.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - node_id: str, - report_id: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, node_id: str, report_id: str, **kwargs: Any ) -> _models.DscNodeReport: """Retrieve the Dsc node report data by node id and report id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The Dsc node id. + :param node_id: The Dsc node id. Required. :type node_id: str - :param report_id: The report id. + :param report_id: The report id. Required. :type report_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: DscNodeReport, or the result of cls(response) + :return: DscNodeReport or the result of cls(response) :rtype: ~azure.mgmt.automation.models.DscNodeReport - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.DscNodeReport] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.DscNodeReport] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -320,7 +299,7 @@ def get( report_id=report_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -328,10 +307,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -339,55 +317,43 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('DscNodeReport', pipeline_response) + deserialized = self._deserialize("DscNodeReport", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}"} # type: ignore @distributed_trace def get_content( - self, - resource_group_name: str, - automation_account_name: str, - node_id: str, - report_id: str, - **kwargs: Any - ) -> Any: + self, resource_group_name: str, automation_account_name: str, node_id: str, report_id: str, **kwargs: Any + ) -> JSON: """Retrieve the Dsc node reports by node id and report id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param node_id: The Dsc node id. + :param node_id: The Dsc node id. Required. :type node_id: str - :param report_id: The report id. + :param report_id: The report id. Required. :type report_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: any, or the result of cls(response) - :rtype: any - :raises: ~azure.core.exceptions.HttpResponseError + :return: JSON or the result of cls(response) + :rtype: JSON + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[Any] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[JSON] - request = build_get_content_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -395,7 +361,7 @@ def get_content( report_id=report_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_content.metadata['url'], + template_url=self.get_content.metadata["url"], headers=_headers, params=_params, ) @@ -403,10 +369,9 @@ def get_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -414,12 +379,11 @@ def get_content( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('object', pipeline_response) + deserialized = self._deserialize("object", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}/content"} # type: ignore - + get_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/nodes/{nodeId}/reports/{reportId}/content"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_object_data_types_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_object_data_types_operations.py index eac3b99167c2..e4634138b70b 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_object_data_types_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_object_data_types_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +24,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_fields_by_module_and_type_request( resource_group_name: str, automation_account_name: str, @@ -38,73 +45,68 @@ def build_list_fields_by_module_and_type_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/objectDataTypes/{typeName}/fields") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/objectDataTypes/{typeName}/fields", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "moduleName": _SERIALIZER.url("module_name", module_name, 'str'), - "typeName": _SERIALIZER.url("type_name", type_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "moduleName": _SERIALIZER.url("module_name", module_name, "str"), + "typeName": _SERIALIZER.url("type_name", type_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_fields_by_type_request( - resource_group_name: str, - automation_account_name: str, - type_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, type_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/objectDataTypes/{typeName}/fields") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/objectDataTypes/{typeName}/fields", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "typeName": _SERIALIZER.url("type_name", type_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "typeName": _SERIALIZER.url("type_name", type_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ObjectDataTypesOperations: """ @@ -125,47 +127,37 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_fields_by_module_and_type( - self, - resource_group_name: str, - automation_account_name: str, - module_name: str, - type_name: str, - **kwargs: Any - ) -> Iterable[_models.TypeFieldListResult]: + self, resource_group_name: str, automation_account_name: str, module_name: str, type_name: str, **kwargs: Any + ) -> Iterable["_models.TypeField"]: """Retrieve a list of fields of a given type identified by module name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param module_name: The name of module. + :param module_name: The name of module. Required. :type module_name: str - :param type_name: The name of type. + :param type_name: The name of type. Required. :type type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either TypeFieldListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.TypeFieldListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either TypeField or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.TypeField] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.TypeFieldListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.TypeFieldListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_fields_by_module_and_type_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -173,7 +165,7 @@ def prepare_request(next_link=None): type_name=type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_fields_by_module_and_type.metadata['url'], + template_url=self.list_fields_by_module_and_type.metadata["url"], headers=_headers, params=_params, ) @@ -181,18 +173,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_fields_by_module_and_type_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - module_name=module_name, - type_name=type_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -208,10 +189,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -222,56 +201,46 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_fields_by_module_and_type.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/objectDataTypes/{typeName}/fields"} # type: ignore + list_fields_by_module_and_type.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/modules/{moduleName}/objectDataTypes/{typeName}/fields"} # type: ignore @distributed_trace def list_fields_by_type( - self, - resource_group_name: str, - automation_account_name: str, - type_name: str, - **kwargs: Any - ) -> Iterable[_models.TypeFieldListResult]: + self, resource_group_name: str, automation_account_name: str, type_name: str, **kwargs: Any + ) -> Iterable["_models.TypeField"]: """Retrieve a list of fields of a given type across all accessible modules. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param type_name: The name of type. + :param type_name: The name of type. Required. :type type_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either TypeFieldListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.TypeFieldListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either TypeField or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.TypeField] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.TypeFieldListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.TypeFieldListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_fields_by_type_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, type_name=type_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_fields_by_type.metadata['url'], + template_url=self.list_fields_by_type.metadata["url"], headers=_headers, params=_params, ) @@ -279,17 +248,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_fields_by_type_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - type_name=type_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -305,10 +264,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -319,8 +276,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_fields_by_type.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/objectDataTypes/{typeName}/fields"} # type: ignore + list_fields_by_type.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/objectDataTypes/{typeName}/fields"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_operations.py index e979e997de9c..8d87b837dea5 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,38 +24,34 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False -def build_list_request( - **kwargs: Any -) -> HttpRequest: + +def build_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL _url = kwargs.pop("template_url", "/providers/Microsoft.Automation/operations") # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Operations: """ @@ -72,38 +72,30 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace - def list( - self, - **kwargs: Any - ) -> Iterable[_models.OperationListResult]: + def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: """Lists all of the available Automation REST API operations. - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either OperationListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.OperationListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Operation or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Operation] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.OperationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_request( api_version=api_version, - template_url=self.list.metadata['url'], + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -111,13 +103,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_request( - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -133,10 +119,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -147,8 +131,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list.metadata = {'url': "/providers/Microsoft.Automation/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.Automation/operations"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_patch.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_patch.py index 0ad201a8c586..f7dd32510333 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_patch.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_patch.py @@ -10,6 +10,7 @@ __all__: List[str] = [] # Add all objects you want publicly available to users at this package level + def patch_sdk(): """Do not remove from this file. diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_private_endpoint_connections_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_private_endpoint_connections_operations.py index a99cecb5b88f..5333f9fd6a7c 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_private_endpoint_connections_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_private_endpoint_connections_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, cast, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -22,173 +26,171 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_by_automation_account_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, private_endpoint_connection_name: str, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "privateEndpointConnectionName": _SERIALIZER.url("private_endpoint_connection_name", private_endpoint_connection_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "privateEndpointConnectionName": _SERIALIZER.url( + "private_endpoint_connection_name", private_endpoint_connection_name, "str" + ), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_create_or_update_request_initial( - subscription_id: str, +def build_create_or_update_request( resource_group_name: str, automation_account_name: str, private_endpoint_connection_name: str, - *, - json: Optional[_models.PrivateEndpointConnection] = None, - content: Any = None, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "privateEndpointConnectionName": _SERIALIZER.url("private_endpoint_connection_name", private_endpoint_connection_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "privateEndpointConnectionName": _SERIALIZER.url( + "private_endpoint_connection_name", private_endpoint_connection_name, "str" + ), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) -def build_delete_request_initial( - subscription_id: str, +def build_delete_request( resource_group_name: str, automation_account_name: str, private_endpoint_connection_name: str, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "privateEndpointConnectionName": _SERIALIZER.url("private_endpoint_connection_name", private_endpoint_connection_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "privateEndpointConnectionName": _SERIALIZER.url( + "private_endpoint_connection_name", private_endpoint_connection_name, "str" + ), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateEndpointConnectionsOperations: """ @@ -209,49 +211,40 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.PrivateEndpointConnectionListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.PrivateEndpointConnection"]: """List all private endpoint connections on a Automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateEndpointConnectionListResult or the result - of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.PrivateEndpointConnectionListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either PrivateEndpointConnection or the result of + cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.PrivateEndpointConnection] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -259,16 +252,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -284,10 +268,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -297,11 +279,9 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections"} # type: ignore @distributed_trace def get( @@ -313,39 +293,33 @@ def get( ) -> _models.PrivateEndpointConnection: """Gets a private endpoint connection. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param private_endpoint_connection_name: The name of the private endpoint connection. + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. :type private_endpoint_connection_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PrivateEndpointConnection, or the result of cls(response) + :return: PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.mgmt.automation.models.PrivateEndpointConnection - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, private_endpoint_connection_name=private_endpoint_connection_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -353,57 +327,60 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _create_or_update_initial( self, resource_group_name: str, automation_account_name: str, private_endpoint_connection_name: str, - parameters: _models.PrivateEndpointConnection, + parameters: Union[_models.PrivateEndpointConnection, IO], **kwargs: Any ) -> Optional[_models.PrivateEndpointConnection]: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PrivateEndpointConnection]] - _json = self._serialize.body(parameters, 'PrivateEndpointConnection') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PrivateEndpointConnection") - request = build_create_or_update_request_initial( - subscription_id=self._config.subscription_id, + request = build_create_or_update_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, private_endpoint_connection_name=private_endpoint_connection_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self._create_or_update_initial.metadata['url'], + content=_content, + template_url=self._create_or_update_initial.metadata["url"], headers=_headers, params=_params, ) @@ -411,50 +388,51 @@ def _create_or_update_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) deserialized = None if response.status_code == 200: - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + _create_or_update_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - - @distributed_trace + @overload def begin_create_or_update( self, resource_group_name: str, automation_account_name: str, private_endpoint_connection_name: str, parameters: _models.PrivateEndpointConnection, + *, + content_type: str = "application/json", **kwargs: Any ) -> LROPoller[_models.PrivateEndpointConnection]: """Approve or reject a private endpoint connection with a given name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param private_endpoint_connection_name: The name of the private endpoint connection. + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. :type private_endpoint_connection_name: str - :param parameters: + :param parameters: Required. :type parameters: ~azure.mgmt.automation.models.PrivateEndpointConnection - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -466,20 +444,91 @@ def begin_create_or_update( :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.PrivateEndpointConnection] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + private_endpoint_connection_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.PrivateEndpointConnection]: + """Approve or reject a private endpoint connection with a given name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. + :type private_endpoint_connection_name: str + :param parameters: Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result + of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.PrivateEndpointConnection] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + private_endpoint_connection_name: str, + parameters: Union[_models.PrivateEndpointConnection, IO], + **kwargs: Any + ) -> LROPoller[_models.PrivateEndpointConnection]: + """Approve or reject a private endpoint connection with a given name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. + :type private_endpoint_connection_name: str + :param parameters: Is either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.PrivateEndpointConnection or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either PrivateEndpointConnection or the result + of cls(response) + :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.automation.models.PrivateEndpointConnection] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnection] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, @@ -488,39 +537,35 @@ def begin_create_or_update( parameters=parameters, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) + deserialized = self._deserialize("PrivateEndpointConnection", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore def _delete_initial( # pylint: disable=inconsistent-return-statements self, @@ -529,25 +574,22 @@ def _delete_initial( # pylint: disable=inconsistent-return-statements private_endpoint_connection_name: str, **kwargs: Any ) -> None: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_request_initial( - subscription_id=self._config.subscription_id, + request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, private_endpoint_connection_name=private_endpoint_connection_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._delete_initial.metadata['url'], + template_url=self._delete_initial.metadata["url"], headers=_headers, params=_params, ) @@ -555,24 +597,23 @@ def _delete_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202, 204]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {}) - _delete_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore - + _delete_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore @distributed_trace - def begin_delete( # pylint: disable=inconsistent-return-statements + def begin_delete( self, resource_group_name: str, automation_account_name: str, @@ -581,15 +622,12 @@ def begin_delete( # pylint: disable=inconsistent-return-statements ) -> LROPoller[None]: """Deletes a private endpoint connection with a given name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param private_endpoint_connection_name: The name of the private endpoint connection. + :param private_endpoint_connection_name: The name of the private endpoint connection. Required. :type private_endpoint_connection_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -600,53 +638,46 @@ def begin_delete( # pylint: disable=inconsistent-return-statements Retry-After header is present. :return: An instance of LROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[None] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore resource_group_name=resource_group_name, automation_account_name=automation_account_name, private_endpoint_connection_name=private_endpoint_connection_name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + begin_delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_private_link_resources_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_private_link_resources_operations.py index 19d9ed93f68c..e162b2a1f449 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_private_link_resources_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_private_link_resources_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,48 +24,48 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_automation_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateLinkResources") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateLinkResources", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class PrivateLinkResourcesOperations: """ @@ -82,49 +86,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def automation( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.PrivateLinkResourceListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.PrivateLinkResource"]: """Gets the private link resources that need to be created for Automation account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PrivateLinkResourceListResult or the result of - cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.PrivateLinkResourceListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either PrivateLinkResource or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.PrivateLinkResource] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourceListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_automation_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.automation.metadata['url'], + template_url=self.automation.metadata["url"], headers=_headers, params=_params, ) @@ -132,16 +126,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_automation_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -157,10 +142,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -170,8 +153,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - automation.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateLinkResources"} # type: ignore + automation.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/privateLinkResources"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_python2_package_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_python2_package_operations.py index b4da448c5053..165665114437 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_python2_package_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_python2_package_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,220 +24,190 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_delete_request( - resource_group_name: str, - automation_account_name: str, - package_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, package_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "packageName": _SERIALIZER.url("package_name", package_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "packageName": _SERIALIZER.url("package_name", package_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - package_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, package_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "packageName": _SERIALIZER.url("package_name", package_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "packageName": _SERIALIZER.url("package_name", package_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - package_name: str, - subscription_id: str, - *, - json: Optional[_models.PythonPackageCreateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, package_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "packageName": _SERIALIZER.url("package_name", package_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "packageName": _SERIALIZER.url("package_name", package_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - package_name: str, - subscription_id: str, - *, - json: Optional[_models.PythonPackageUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, package_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "packageName": _SERIALIZER.url("package_name", package_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "packageName": _SERIALIZER.url("package_name", package_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class Python2PackageOperations: """ @@ -254,50 +228,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - package_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, package_name: str, **kwargs: Any ) -> None: """Delete the python 2 package by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param package_name: The python package name. + :param package_name: The python package name. Required. :type package_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, package_name=package_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +268,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -319,52 +281,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - package_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, package_name: str, **kwargs: Any ) -> _models.Module: """Retrieve the python 2 package identified by package name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param package_name: The python package name. + :param package_name: The python package name. Required. :type package_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, package_name=package_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -372,10 +323,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -383,56 +333,120 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, package_name: str, parameters: _models.PythonPackageCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Module: """Create or Update the python 2 package identified by package name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param package_name: The name of python package. + :param package_name: The name of python package. Required. :type package_name: str - :param parameters: The create or update parameters for python package. + :param parameters: The create or update parameters for python package. Required. :type parameters: ~azure.mgmt.automation.models.PythonPackageCreateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 2 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: Union[_models.PythonPackageCreateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 2 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Is either a model type + or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - _json = self._serialize.body(parameters, 'PythonPackageCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PythonPackageCreateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -442,7 +456,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -450,10 +465,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -462,59 +476,123 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, package_name: str, parameters: _models.PythonPackageUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Module: """Update the python 2 package identified by package name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param package_name: The name of python package. + :param package_name: The name of python package. Required. :type package_name: str - :param parameters: The update parameters for python package. + :param parameters: The update parameters for python package. Required. :type parameters: ~azure.mgmt.automation.models.PythonPackageUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Module, or the result of cls(response) + :return: Module or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Module - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Update the python 2 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: Union[_models.PythonPackageUpdateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Update the python 2 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Module] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] - _json = self._serialize.body(parameters, 'PythonPackageUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PythonPackageUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -524,7 +602,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -532,10 +611,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -543,56 +621,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Module', pipeline_response) + deserialized = self._deserialize("Module", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages/{packageName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.ModuleListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Module"]: """Retrieve a list of python 2 packages. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ModuleListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.ModuleListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Module or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Module] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ModuleListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ModuleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -600,16 +670,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -625,10 +686,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -639,8 +698,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python2Packages"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_python3_package_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_python3_package_operations.py new file mode 100644 index 000000000000..1887ad631ea6 --- /dev/null +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_python3_package_operations.py @@ -0,0 +1,703 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) +from azure.core.paging import ItemPaged +from azure.core.pipeline import PipelineResponse +from azure.core.pipeline.transport import HttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict +from azure.mgmt.core.exceptions import ARMErrorFormat + +from .. import models as _models +from .._serialization import Serializer +from .._vendor import MixinABC, _convert_request, _format_url_section + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_delete_request( + resource_group_name: str, automation_account_name: str, package_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "packageName": _SERIALIZER.url("package_name", package_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_request( + resource_group_name: str, automation_account_name: str, package_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "packageName": _SERIALIZER.url("package_name", package_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_create_or_update_request( + resource_group_name: str, automation_account_name: str, package_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "packageName": _SERIALIZER.url("package_name", package_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_update_request( + resource_group_name: str, automation_account_name: str, package_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}", + ) # pylint: disable=line-too-long + path_format_arguments = { + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "packageName": _SERIALIZER.url("package_name", package_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_list_by_automation_account_request( + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages", + ) # pylint: disable=line-too-long + path_format_arguments = { + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +class Python3PackageOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.automation.AutomationClient`'s + :attr:`python3_package` attribute. + """ + + models = _models + + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, automation_account_name: str, package_name: str, **kwargs: Any + ) -> None: + """Delete the python 3 package by name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The python package name. Required. + :type package_name: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + + request = build_delete_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + package_name=package_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.delete.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) + + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}"} # type: ignore + + @distributed_trace + def get( + self, resource_group_name: str, automation_account_name: str, package_name: str, **kwargs: Any + ) -> _models.Module: + """Retrieve the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The python package name. Required. + :type package_name: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] + + request = build_get_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + package_name=package_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.get.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Module", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}"} # type: ignore + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: _models.PythonPackageCreateParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageCreateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: Union[_models.PythonPackageCreateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Create or Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The create or update parameters for python package. Is either a model type + or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PythonPackageCreateParameters") + + request = build_create_or_update_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + package_name=package_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create_or_update.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + if response.status_code == 200: + deserialized = self._deserialize("Module", pipeline_response) + + if response.status_code == 201: + deserialized = self._deserialize("Module", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}"} # type: ignore + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: _models.PythonPackageUpdateParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageUpdateParameters + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Module: + """Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + package_name: str, + parameters: Union[_models.PythonPackageUpdateParameters, IO], + **kwargs: Any + ) -> _models.Module: + """Update the python 3 package identified by package name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param package_name: The name of python package. Required. + :type package_name: str + :param parameters: The update parameters for python package. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.PythonPackageUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Module or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Module + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Module] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "PythonPackageUpdateParameters") + + request = build_update_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + package_name=package_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.update.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + deserialized = self._deserialize("Module", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages/{packageName}"} # type: ignore + + @distributed_trace + def list_by_automation_account( + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Module"]: + """Retrieve a list of python 3 packages. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: An iterator like instance of either Module or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Module] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ModuleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + request = build_list_by_automation_account_request( + resource_group_name=resource_group_name, + automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + + else: + request = HttpRequest("GET", next_link) + request = _convert_request(request) + request.url = self._client.format_url(request.url) # type: ignore + request.method = "GET" + return request + + def extract_data(pipeline_response): + deserialized = self._deserialize("ModuleListResult", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) + return deserialized.next_link or None, iter(list_of_elem) + + def get_next(next_link=None): + request = prepare_request(next_link) + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/python3Packages"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_runbook_draft_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_runbook_draft_operations.py index 3970c28c430b..6713dbe1e3d9 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_runbook_draft_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_runbook_draft_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterator, Optional, TypeVar, Union, cast + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.polling import LROPoller, NoPolling, PollingMethod @@ -21,173 +25,160 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_content_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "text/powershell") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "text/powershell") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_replace_content_request_initial( - subscription_id: str, +def build_replace_content_request( resource_group_name: str, automation_account_name: str, runbook_name: str, + subscription_id: str, *, - content: Any, + content: IO, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, content=content, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_undo_edit_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/undoEdit") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/undoEdit", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class RunbookDraftOperations: """ @@ -208,50 +199,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def get_content( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any - ) -> IO: + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any + ) -> Iterator[bytes]: """Retrieve the content of runbook draft identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: IO, or the result of cls(response) - :rtype: IO - :raises: ~azure.core.exceptions.HttpResponseError + :return: Iterator of the response bytes or the result of cls(response) + :rtype: Iterator[bytes] + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[IO] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Iterator[bytes]] - request = build_get_content_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_content.metadata['url'], + template_url=self.get_content.metadata["url"], headers=_headers, params=_params, ) @@ -259,57 +239,53 @@ def get_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=True, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('IO', pipeline_response) + deserialized = response.stream_download(self._client._pipeline) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore - + get_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore - def _replace_content_initial( + def _replace_content_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, automation_account_name: str, runbook_name: str, - runbook_content: str, + runbook_content: IO, **kwargs: Any - ) -> Optional[IO]: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + ) -> None: + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "text/powershell")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[Optional[IO]] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] _content = runbook_content - request = build_replace_content_request_initial( - subscription_id=self._config.subscription_id, + request = build_replace_content_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, content=_content, - template_url=self._replace_content_initial.metadata['url'], + template_url=self._replace_content_initial.metadata["url"], headers=_headers, params=_params, ) @@ -317,32 +293,24 @@ def _replace_content_initial( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=True, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = None response_headers = {} - if response.status_code == 200: - deserialized = response.stream_download(self._client._pipeline) - if response.status_code == 202: - response_headers['location']=self._deserialize('str', response.headers.get('location')) - + response_headers["location"] = self._deserialize("str", response.headers.get("location")) if cls: - return cls(pipeline_response, deserialized, response_headers) - - return deserialized - - _replace_content_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore + return cls(pipeline_response, None, response_headers) + _replace_content_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore @distributed_trace def begin_replace_content( @@ -350,22 +318,19 @@ def begin_replace_content( resource_group_name: str, automation_account_name: str, runbook_name: str, - runbook_content: str, + runbook_content: IO, **kwargs: Any - ) -> LROPoller[IO]: + ) -> LROPoller[None]: """Replaces the runbook draft content. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :param runbook_content: The runbook draft content. - :type runbook_content: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :param runbook_content: The runbook draft content. Required. + :type runbook_content: IO :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -374,22 +339,19 @@ def begin_replace_content( :paramtype polling: bool or ~azure.core.polling.PollingMethod :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. - :return: An instance of LROPoller that returns either IO or the result of cls(response) - :rtype: ~azure.core.polling.LROPoller[IO] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An instance of LROPoller that returns either None or the result of cls(response) + :rtype: ~azure.core.polling.LROPoller[None] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "text/powershell")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[IO] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._replace_content_initial( # type: ignore resource_group_name=resource_group_name, @@ -398,83 +360,69 @@ def begin_replace_content( runbook_content=runbook_content, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): - deserialized = response.stream_download(self._client._pipeline) + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: - return cls(pipeline_response, deserialized, {}) - return deserialized - + return cls(pipeline_response, None, {}) if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast( + PollingMethod, ARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs) + ) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_replace_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore + begin_replace_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/content"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> _models.RunbookDraft: """Retrieve the runbook draft identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: RunbookDraft, or the result of cls(response) + :return: RunbookDraft or the result of cls(response) :rtype: ~azure.mgmt.automation.models.RunbookDraft - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.RunbookDraft] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.RunbookDraft] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -482,10 +430,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -493,59 +440,48 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('RunbookDraft', pipeline_response) + deserialized = self._deserialize("RunbookDraft", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft"} # type: ignore @distributed_trace - def undo_edit( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any - ) -> _models.RunbookDraftUndoEditResult: + def undo_edit( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any + ) -> None: """Undo draft edit to last known published state identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: RunbookDraftUndoEditResult, or the result of cls(response) - :rtype: ~azure.mgmt.automation.models.RunbookDraftUndoEditResult - :raises: ~azure.core.exceptions.HttpResponseError + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.RunbookDraftUndoEditResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_undo_edit_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.undo_edit.metadata['url'], + template_url=self.undo_edit.metadata["url"], headers=_headers, params=_params, ) @@ -553,10 +489,9 @@ def undo_edit( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -564,12 +499,7 @@ def undo_edit( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('RunbookDraftUndoEditResult', pipeline_response) - if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized - - undo_edit.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/undoEdit"} # type: ignore + return cls(pipeline_response, None, {}) + undo_edit.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/undoEdit"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_runbook_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_runbook_operations.py index c98400d7b8fc..bfc58d6e22e3 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_runbook_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_runbook_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, cast - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Iterator, Optional, TypeVar, Union, cast, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -22,298 +26,258 @@ from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False -def build_publish_request_initial( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + +def build_publish_request( + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_get_content_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "text/powershell") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "text/powershell") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/content") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/content", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - *, - json: Optional[_models.RunbookCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - *, - json: Optional[_models.RunbookUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_delete_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class RunbookOperations: """ @@ -334,33 +298,25 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - def _publish_initial( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_publish_request_initial( - subscription_id=self._config.subscription_id, + request = build_publish_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self._publish_initial.metadata['url'], + template_url=self._publish_initial.metadata["url"], headers=_headers, params=_params, ) @@ -368,45 +324,36 @@ def _publish_initial( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) + error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) response_headers = {} - response_headers['location']=self._deserialize('str', response.headers.get('location')) - + response_headers["location"] = self._deserialize("str", response.headers.get("location")) if cls: return cls(pipeline_response, None, response_headers) - _publish_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish"} # type: ignore - + _publish_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish"} # type: ignore @distributed_trace - def begin_publish( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + def begin_publish( + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> LROPoller[None]: """Publish runbook draft. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The parameters supplied to the publish runbook operation. + :param runbook_name: The parameters supplied to the publish runbook operation. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this @@ -417,100 +364,83 @@ def begin_publish( # pylint: disable=inconsistent-return-statements Retry-After header is present. :return: An instance of LROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[None] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] - polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: raw_result = self._publish_initial( # type: ignore resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - if polling is True: - polling_method = cast(PollingMethod, ARMPolling( - lro_delay, - - - **kwargs - )) # type: PollingMethod - elif polling is False: polling_method = cast(PollingMethod, NoPolling()) - else: polling_method = polling + polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_publish.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish"} # type: ignore + begin_publish.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/publish"} # type: ignore @distributed_trace def get_content( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any - ) -> IO: + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any + ) -> Iterator[bytes]: """Retrieve the content of runbook identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: IO, or the result of cls(response) - :rtype: IO - :raises: ~azure.core.exceptions.HttpResponseError + :return: Iterator of the response bytes or the result of cls(response) + :rtype: Iterator[bytes] + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[IO] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[Iterator[bytes]] - request = build_get_content_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get_content.metadata['url'], + template_url=self.get_content.metadata["url"], headers=_headers, params=_params, ) @@ -518,69 +448,57 @@ def get_content( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=True, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) - deserialized = self._deserialize('IO', pipeline_response) + deserialized = response.stream_download(self._client._pipeline) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_content.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/content"} # type: ignore - + get_content.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/content"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> _models.Runbook: """Retrieve the runbook identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Runbook, or the result of cls(response) + :return: Runbook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Runbook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Runbook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Runbook] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -588,10 +506,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -599,67 +516,133 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Runbook', pipeline_response) + deserialized = self._deserialize("Runbook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, runbook_name: str, parameters: _models.RunbookCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Runbook: """Create the runbook identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str :param parameters: The create or update parameters for runbook. Provide either content link for - a published runbook or draft, not both. + a published runbook or draft, not both. Required. :type parameters: ~azure.mgmt.automation.models.RunbookCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Runbook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Runbook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Runbook: + """Create the runbook identified by runbook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The runbook name. Required. + :type runbook_name: str + :param parameters: The create or update parameters for runbook. Provide either content link for + a published runbook or draft, not both. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Runbook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Runbook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: Union[_models.RunbookCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Runbook: + """Create the runbook identified by runbook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The runbook name. Required. + :type runbook_name: str + :param parameters: The create or update parameters for runbook. Provide either content link for + a published runbook or draft, not both. Is either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.RunbookCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Runbook, or the result of cls(response) + :return: Runbook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Runbook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Runbook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Runbook] - _json = self._serialize.body(parameters, 'RunbookCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "RunbookCreateOrUpdateParameters") request = build_create_or_update_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -667,10 +650,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -679,69 +661,134 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Runbook', pipeline_response) + deserialized = self._deserialize("Runbook", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Runbook', pipeline_response) + deserialized = self._deserialize("Runbook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, runbook_name: str, parameters: _models.RunbookUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Runbook: """Update the runbook identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :param parameters: The update parameters for runbook. + :param parameters: The update parameters for runbook. Required. :type parameters: ~azure.mgmt.automation.models.RunbookUpdateParameters - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Runbook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Runbook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Runbook: + """Update the runbook identified by runbook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The runbook name. Required. + :type runbook_name: str + :param parameters: The update parameters for runbook. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Runbook, or the result of cls(response) + :return: Runbook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Runbook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: Union[_models.RunbookUpdateParameters, IO], + **kwargs: Any + ) -> _models.Runbook: + """Update the runbook identified by runbook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The runbook name. Required. + :type runbook_name: str + :param parameters: The update parameters for runbook. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.automation.models.RunbookUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Runbook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Runbook + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Runbook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Runbook] - _json = self._serialize.body(parameters, 'RunbookUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "RunbookUpdateParameters") request = build_update_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -749,10 +796,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -760,59 +806,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Runbook', pipeline_response) + deserialized = self._deserialize("Runbook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: """Delete the runbook by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -820,10 +855,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -834,49 +868,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.RunbookListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Runbook"]: """Retrieve a list of runbooks. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either RunbookListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.RunbookListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Runbook or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Runbook] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.RunbookListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.RunbookListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -884,16 +910,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -909,10 +926,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -923,8 +938,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_schedule_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_schedule_operations.py index 07b569b55b6d..546f1ead211a 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_schedule_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_schedule_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,220 +24,190 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - schedule_name: str, - subscription_id: str, - *, - json: Optional[_models.ScheduleCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, schedule_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "scheduleName": _SERIALIZER.url("schedule_name", schedule_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "scheduleName": _SERIALIZER.url("schedule_name", schedule_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - schedule_name: str, - subscription_id: str, - *, - json: Optional[_models.ScheduleUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, schedule_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "scheduleName": _SERIALIZER.url("schedule_name", schedule_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "scheduleName": _SERIALIZER.url("schedule_name", schedule_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - schedule_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, schedule_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "scheduleName": _SERIALIZER.url("schedule_name", schedule_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "scheduleName": _SERIALIZER.url("schedule_name", schedule_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_delete_request( - resource_group_name: str, - automation_account_name: str, - schedule_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, schedule_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "scheduleName": _SERIALIZER.url("schedule_name", schedule_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "scheduleName": _SERIALIZER.url("schedule_name", schedule_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class ScheduleOperations: """ @@ -254,47 +228,113 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, schedule_name: str, parameters: _models.ScheduleCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> Optional[_models.Schedule]: """Create a schedule. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param schedule_name: The schedule name. + :param schedule_name: The schedule name. Required. :type schedule_name: str :param parameters: The parameters supplied to the create or update schedule operation. + Required. :type parameters: ~azure.mgmt.automation.models.ScheduleCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Schedule or None or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Schedule or None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + schedule_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> Optional[_models.Schedule]: + """Create a schedule. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param schedule_name: The schedule name. Required. + :type schedule_name: str + :param parameters: The parameters supplied to the create or update schedule operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Schedule or None or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Schedule or None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + schedule_name: str, + parameters: Union[_models.ScheduleCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> Optional[_models.Schedule]: + """Create a schedule. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param schedule_name: The schedule name. Required. + :type schedule_name: str + :param parameters: The parameters supplied to the create or update schedule operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ScheduleCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Schedule, or the result of cls(response) + :return: Schedule or None or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Schedule or None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[Optional[_models.Schedule]] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.Schedule]] - _json = self._serialize.body(parameters, 'ScheduleCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ScheduleCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -304,7 +344,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -312,10 +353,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201, 409]: @@ -325,59 +365,123 @@ def create_or_update( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('Schedule', pipeline_response) + deserialized = self._deserialize("Schedule", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Schedule', pipeline_response) + deserialized = self._deserialize("Schedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, schedule_name: str, parameters: _models.ScheduleUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Schedule: """Update the schedule identified by schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param schedule_name: The schedule name. + :param schedule_name: The schedule name. Required. :type schedule_name: str - :param parameters: The parameters supplied to the update schedule operation. + :param parameters: The parameters supplied to the update schedule operation. Required. :type parameters: ~azure.mgmt.automation.models.ScheduleUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Schedule or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Schedule + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + schedule_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Schedule: + """Update the schedule identified by schedule name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param schedule_name: The schedule name. Required. + :type schedule_name: str + :param parameters: The parameters supplied to the update schedule operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Schedule, or the result of cls(response) + :return: Schedule or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Schedule - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + schedule_name: str, + parameters: Union[_models.ScheduleUpdateParameters, IO], + **kwargs: Any + ) -> _models.Schedule: + """Update the schedule identified by schedule name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param schedule_name: The schedule name. Required. + :type schedule_name: str + :param parameters: The parameters supplied to the update schedule operation. Is either a model + type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.ScheduleUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Schedule or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Schedule + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Schedule] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Schedule] - _json = self._serialize.body(parameters, 'ScheduleUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ScheduleUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -387,7 +491,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -395,10 +500,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -406,59 +510,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Schedule', pipeline_response) + deserialized = self._deserialize("Schedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - schedule_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, schedule_name: str, **kwargs: Any ) -> _models.Schedule: """Retrieve the schedule identified by schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param schedule_name: The schedule name. + :param schedule_name: The schedule name. Required. :type schedule_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Schedule, or the result of cls(response) + :return: Schedule or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Schedule - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Schedule] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Schedule] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, schedule_name=schedule_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -466,10 +559,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -477,59 +569,48 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Schedule', pipeline_response) + deserialized = self._deserialize("Schedule", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - schedule_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, schedule_name: str, **kwargs: Any ) -> None: """Delete the schedule identified by schedule name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param schedule_name: The schedule name. + :param schedule_name: The schedule name. Required. :type schedule_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, schedule_name=schedule_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -537,10 +618,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -551,49 +631,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules/{scheduleName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.ScheduleListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Schedule"]: """Retrieve a list of schedules. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ScheduleListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.ScheduleListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Schedule or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Schedule] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.ScheduleListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ScheduleListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -601,16 +673,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -626,10 +689,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -640,8 +701,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/schedules"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configuration_machine_runs_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configuration_machine_runs_operations.py index 9b238efee258..cc1338c22686 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configuration_machine_runs_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configuration_machine_runs_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,18 +23,21 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_by_id_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, software_update_configuration_machine_run_id: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -38,41 +45,42 @@ def build_get_by_id_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns/{softwareUpdateConfigurationMachineRunId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns/{softwareUpdateConfigurationMachineRunId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "softwareUpdateConfigurationMachineRunId": _SERIALIZER.url("software_update_configuration_machine_run_id", software_update_configuration_machine_run_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "softwareUpdateConfigurationMachineRunId": _SERIALIZER.url( + "software_update_configuration_machine_run_id", software_update_configuration_machine_run_id, "str" + ), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, filter: Optional[str] = None, @@ -83,40 +91,40 @@ def build_list_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") if skip is not None: - _params['$skip'] = _SERIALIZER.query("skip", skip, 'str') + _params["$skip"] = _SERIALIZER.query("skip", skip, "str") if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'str') + _params["$top"] = _SERIALIZER.query("top", top, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SoftwareUpdateConfigurationMachineRunsOperations: """ @@ -137,7 +145,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def get_by_id( self, @@ -149,43 +156,37 @@ def get_by_id( ) -> _models.SoftwareUpdateConfigurationMachineRun: """Get a single software update configuration machine run by Id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_machine_run_id: The Id of the software update - configuration machine run. + configuration machine run. Required. :type software_update_configuration_machine_run_id: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationMachineRun, or the result of cls(response) + :return: SoftwareUpdateConfigurationMachineRun or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationMachineRun - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationMachineRun] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationMachineRun] - request = build_get_by_id_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_machine_run_id=software_update_configuration_machine_run_id, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_by_id.metadata['url'], + api_version=api_version, + template_url=self.get_by_id.metadata["url"], headers=_headers, params=_params, ) @@ -193,10 +194,9 @@ def get_by_id( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -204,15 +204,14 @@ def get_by_id( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationMachineRun', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationMachineRun", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_by_id.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns/{softwareUpdateConfigurationMachineRunId}"} # type: ignore - + get_by_id.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns/{softwareUpdateConfigurationMachineRunId}"} # type: ignore @distributed_trace def list( @@ -227,9 +226,9 @@ def list( ) -> _models.SoftwareUpdateConfigurationMachineRunListResult: """Return list of software update configuration machine runs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str @@ -242,36 +241,30 @@ def list( :param top: Maximum number of entries returned in the results collection. Default value is None. :type top: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationMachineRunListResult, or the result of cls(response) + :return: SoftwareUpdateConfigurationMachineRunListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationMachineRunListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationMachineRunListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationMachineRunListResult] - request = build_list_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, filter=filter, skip=skip, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -279,10 +272,9 @@ def list( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -290,12 +282,11 @@ def list( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationMachineRunListResult', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationMachineRunListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns"} # type: ignore - + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationMachineRuns"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configuration_runs_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configuration_runs_operations.py index c49dff76d558..a2f5a98abf16 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configuration_runs_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configuration_runs_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,18 +23,21 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_by_id_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, software_update_configuration_run_id: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -38,41 +45,42 @@ def build_get_by_id_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns/{softwareUpdateConfigurationRunId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns/{softwareUpdateConfigurationRunId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "softwareUpdateConfigurationRunId": _SERIALIZER.url("software_update_configuration_run_id", software_update_configuration_run_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "softwareUpdateConfigurationRunId": _SERIALIZER.url( + "software_update_configuration_run_id", software_update_configuration_run_id, "str" + ), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, filter: Optional[str] = None, @@ -83,40 +91,40 @@ def build_list_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") if skip is not None: - _params['$skip'] = _SERIALIZER.query("skip", skip, 'str') + _params["$skip"] = _SERIALIZER.query("skip", skip, "str") if top is not None: - _params['$top'] = _SERIALIZER.query("top", top, 'str') + _params["$top"] = _SERIALIZER.query("top", top, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SoftwareUpdateConfigurationRunsOperations: """ @@ -137,7 +145,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def get_by_id( self, @@ -149,42 +156,37 @@ def get_by_id( ) -> _models.SoftwareUpdateConfigurationRun: """Get a single software update configuration Run by Id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_run_id: The Id of the software update configuration run. + Required. :type software_update_configuration_run_id: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationRun, or the result of cls(response) + :return: SoftwareUpdateConfigurationRun or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationRun - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationRun] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationRun] - request = build_get_by_id_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_run_id=software_update_configuration_run_id, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_by_id.metadata['url'], + api_version=api_version, + template_url=self.get_by_id.metadata["url"], headers=_headers, params=_params, ) @@ -192,10 +194,9 @@ def get_by_id( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -203,15 +204,14 @@ def get_by_id( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationRun', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationRun", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_by_id.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns/{softwareUpdateConfigurationRunId}"} # type: ignore - + get_by_id.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns/{softwareUpdateConfigurationRunId}"} # type: ignore @distributed_trace def list( @@ -226,9 +226,9 @@ def list( ) -> _models.SoftwareUpdateConfigurationRunListResult: """Return list of software update configuration runs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str @@ -241,36 +241,30 @@ def list( :param top: Maximum number of entries returned in the results collection. Default value is None. :type top: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationRunListResult, or the result of cls(response) + :return: SoftwareUpdateConfigurationRunListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationRunListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationRunListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationRunListResult] - request = build_list_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, filter=filter, skip=skip, top=top, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -278,10 +272,9 @@ def list( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -289,12 +282,11 @@ def list( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationRunListResult', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationRunListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns"} # type: ignore - + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurationRuns"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configurations_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configurations_operations.py index 895bcc7ea293..00bec2d06f10 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configurations_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_software_update_configurations_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,68 +23,68 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_create_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, software_update_configuration_name: str, + subscription_id: str, *, - json: Optional[_models.SoftwareUpdateConfiguration] = None, - content: Any = None, client_request_id: Optional[str] = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-06-01")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "softwareUpdateConfigurationName": _SERIALIZER.url("software_update_configuration_name", software_update_configuration_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "softwareUpdateConfigurationName": _SERIALIZER.url( + "software_update_configuration_name", software_update_configuration_name, "str" + ), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_by_name_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, software_update_configuration_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -88,42 +92,43 @@ def build_get_by_name_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-06-01")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "softwareUpdateConfigurationName": _SERIALIZER.url("software_update_configuration_name", software_update_configuration_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "softwareUpdateConfigurationName": _SERIALIZER.url( + "software_update_configuration_name", software_update_configuration_name, "str" + ), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_delete_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, software_update_configuration_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, **kwargs: Any @@ -131,41 +136,42 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-06-01")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "softwareUpdateConfigurationName": _SERIALIZER.url("software_update_configuration_name", software_update_configuration_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "softwareUpdateConfigurationName": _SERIALIZER.url( + "software_update_configuration_name", software_update_configuration_name, "str" + ), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_list_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, + subscription_id: str, *, client_request_id: Optional[str] = None, filter: Optional[str] = None, @@ -174,36 +180,36 @@ def build_list_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2019-06-01")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") # Construct headers if client_request_id is not None: - _headers['clientRequestId'] = _SERIALIZER.header("client_request_id", client_request_id, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["clientRequestId"] = _SERIALIZER.header("client_request_id", client_request_id, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SoftwareUpdateConfigurationsOperations: """ @@ -224,8 +230,7 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace + @overload def create( self, resource_group_name: str, @@ -233,53 +238,126 @@ def create( software_update_configuration_name: str, parameters: _models.SoftwareUpdateConfiguration, client_request_id: Optional[str] = None, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.SoftwareUpdateConfiguration: """Create a new software update configuration with the name given in the URI. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_name: The name of the software update configuration to be - created. + created. Required. :type software_update_configuration_name: str - :param parameters: Request body. + :param parameters: Request body. Required. :type parameters: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SoftwareUpdateConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create( + self, + resource_group_name: str, + automation_account_name: str, + software_update_configuration_name: str, + parameters: IO, + client_request_id: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SoftwareUpdateConfiguration: + """Create a new software update configuration with the name given in the URI. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param software_update_configuration_name: The name of the software update configuration to be + created. Required. + :type software_update_configuration_name: str + :param parameters: Request body. Required. + :type parameters: IO + :param client_request_id: Identifies this specific client request. Default value is None. + :type client_request_id: str + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SoftwareUpdateConfiguration or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create( + self, + resource_group_name: str, + automation_account_name: str, + software_update_configuration_name: str, + parameters: Union[_models.SoftwareUpdateConfiguration, IO], + client_request_id: Optional[str] = None, + **kwargs: Any + ) -> _models.SoftwareUpdateConfiguration: + """Create a new software update configuration with the name given in the URI. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param software_update_configuration_name: The name of the software update configuration to be + created. Required. + :type software_update_configuration_name: str + :param parameters: Request body. Is either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration or IO + :param client_request_id: Identifies this specific client request. Default value is None. + :type client_request_id: str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfiguration, or the result of cls(response) + :return: SoftwareUpdateConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfiguration] - _json = self._serialize.body(parameters, 'SoftwareUpdateConfiguration') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SoftwareUpdateConfiguration") request = build_create_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_name=software_update_configuration_name, + subscription_id=self._config.subscription_id, + client_request_id=client_request_id, api_version=api_version, content_type=content_type, json=_json, - client_request_id=client_request_id, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -287,10 +365,9 @@ def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -299,18 +376,17 @@ def create( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('SoftwareUpdateConfiguration', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfiguration", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('SoftwareUpdateConfiguration', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore @distributed_trace def get_by_name( @@ -323,43 +399,37 @@ def get_by_name( ) -> _models.SoftwareUpdateConfiguration: """Get a single software update configuration by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_name: The name of the software update configuration to be - created. + created. Required. :type software_update_configuration_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfiguration, or the result of cls(response) + :return: SoftwareUpdateConfiguration or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfiguration] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfiguration] - request = build_get_by_name_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_name=software_update_configuration_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.get_by_name.metadata['url'], + api_version=api_version, + template_url=self.get_by_name.metadata["url"], headers=_headers, params=_params, ) @@ -367,10 +437,9 @@ def get_by_name( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -378,15 +447,14 @@ def get_by_name( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfiguration', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfiguration", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_by_name.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore - + get_by_name.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -399,43 +467,37 @@ def delete( # pylint: disable=inconsistent-return-statements ) -> None: """delete a specific software update configuration. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param software_update_configuration_name: The name of the software update configuration to be - created. + created. Required. :type software_update_configuration_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, software_update_configuration_name=software_update_configuration_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, - template_url=self.delete.metadata['url'], + api_version=api_version, + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -443,10 +505,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 204]: @@ -457,8 +518,7 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations/{softwareUpdateConfigurationName}"} # type: ignore @distributed_trace def list( @@ -471,42 +531,36 @@ def list( ) -> _models.SoftwareUpdateConfigurationListResult: """Get all software update configurations for the account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param client_request_id: Identifies this specific client request. Default value is None. :type client_request_id: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2019-06-01". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SoftwareUpdateConfigurationListResult, or the result of cls(response) + :return: SoftwareUpdateConfigurationListResult or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationListResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2019-06-01")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SoftwareUpdateConfigurationListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SoftwareUpdateConfigurationListResult] - request = build_list_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, - api_version=api_version, + subscription_id=self._config.subscription_id, client_request_id=client_request_id, filter=filter, - template_url=self.list.metadata['url'], + api_version=api_version, + template_url=self.list.metadata["url"], headers=_headers, params=_params, ) @@ -514,10 +568,9 @@ def list( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -525,12 +578,11 @@ def list( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SoftwareUpdateConfigurationListResult', pipeline_response) + deserialized = self._deserialize("SoftwareUpdateConfigurationListResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations"} # type: ignore - + list.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/softwareUpdateConfigurations"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_operations.py index deaaac119daa..e72a9c82e927 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,58 +24,55 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_create_or_update_request( resource_group_name: str, automation_account_name: str, source_control_name: str, subscription_id: str, - *, - json: Optional[_models.SourceControlCreateOrUpdateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( @@ -79,46 +80,40 @@ def build_update_request( automation_account_name: str, source_control_name: str, subscription_id: str, - *, - json: Optional[_models.SourceControlUpdateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_delete_request( @@ -131,33 +126,32 @@ def build_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( @@ -170,33 +164,32 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -210,34 +203,34 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SourceControlOperations: """ @@ -258,47 +251,113 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, source_control_name: str, parameters: _models.SourceControlCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.SourceControl: """Create a source control. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str :param parameters: The parameters supplied to the create or update source control operation. + Required. :type parameters: ~azure.mgmt.automation.models.SourceControlCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControl, or the result of cls(response) + :return: SourceControl or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControl - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SourceControl: + """Create a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param parameters: The parameters supplied to the create or update source control operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControl or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControl + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + parameters: Union[_models.SourceControlCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.SourceControl: + """Create a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param parameters: The parameters supplied to the create or update source control operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.SourceControlCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControl or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControl + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControl] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControl] - _json = self._serialize.body(parameters, 'SourceControlCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SourceControlCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -308,7 +367,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -316,10 +376,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -328,59 +387,123 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('SourceControl', pipeline_response) + deserialized = self._deserialize("SourceControl", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('SourceControl', pipeline_response) + deserialized = self._deserialize("SourceControl", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, source_control_name: str, parameters: _models.SourceControlUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.SourceControl: """Update a source control. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param parameters: The parameters supplied to the update source control operation. + :param parameters: The parameters supplied to the update source control operation. Required. :type parameters: ~azure.mgmt.automation.models.SourceControlUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControl, or the result of cls(response) + :return: SourceControl or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControl - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SourceControl: + """Update a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param parameters: The parameters supplied to the update source control operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControl or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControl + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + parameters: Union[_models.SourceControlUpdateParameters, IO], + **kwargs: Any + ) -> _models.SourceControl: + """Update a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param parameters: The parameters supplied to the update source control operation. Is either a + model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.SourceControlUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControl or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControl + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControl] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControl] - _json = self._serialize.body(parameters, 'SourceControlUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SourceControlUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -390,7 +513,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -398,10 +522,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -409,59 +532,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControl', pipeline_response) + deserialized = self._deserialize("SourceControl", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - source_control_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, source_control_name: str, **kwargs: Any ) -> None: """Delete the source control. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The name of source control. + :param source_control_name: The name of source control. Required. :type source_control_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, source_control_name=source_control_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -469,10 +581,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -483,52 +594,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - source_control_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, source_control_name: str, **kwargs: Any ) -> _models.SourceControl: """Retrieve the source control identified by source control name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The name of source control. + :param source_control_name: The name of source control. Required. :type source_control_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControl, or the result of cls(response) + :return: SourceControl or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControl - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControl] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControl] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, source_control_name=source_control_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -536,10 +636,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -547,61 +646,51 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControl', pipeline_response) + deserialized = self._deserialize("SourceControl", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> Iterable[_models.SourceControlListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.SourceControl"]: """Retrieve a list of source controls. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SourceControlListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.SourceControlListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either SourceControl or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.SourceControl] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -609,17 +698,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -635,10 +714,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -649,8 +726,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_sync_job_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_sync_job_operations.py index 4a39dc19943b..8efabb44305e 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_sync_job_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_sync_job_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,60 +24,57 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_create_request( resource_group_name: str, automation_account_name: str, source_control_name: str, source_control_sync_job_id: str, subscription_id: str, - *, - json: Optional[_models.SourceControlSyncJobCreateParameters] = None, - content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "sourceControlSyncJobId": _SERIALIZER.url("source_control_sync_job_id", source_control_sync_job_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "sourceControlSyncJobId": _SERIALIZER.url("source_control_sync_job_id", source_control_sync_job_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( @@ -87,34 +88,33 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "sourceControlSyncJobId": _SERIALIZER.url("source_control_sync_job_id", source_control_sync_job_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "sourceControlSyncJobId": _SERIALIZER.url("source_control_sync_job_id", source_control_sync_job_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -129,35 +129,35 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SourceControlSyncJobOperations: """ @@ -178,8 +178,7 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace + @overload def create( self, resource_group_name: str, @@ -187,41 +186,114 @@ def create( source_control_name: str, source_control_sync_job_id: str, parameters: _models.SourceControlSyncJobCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.SourceControlSyncJob: """Creates the sync job for a source control. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param source_control_sync_job_id: The source control sync job id. + :param source_control_sync_job_id: The source control sync job id. Required. :type source_control_sync_job_id: str :param parameters: The parameters supplied to the create source control sync job operation. + Required. :type parameters: ~azure.mgmt.automation.models.SourceControlSyncJobCreateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControlSyncJob, or the result of cls(response) + :return: SourceControlSyncJob or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControlSyncJob - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def create( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + source_control_sync_job_id: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SourceControlSyncJob: + """Creates the sync job for a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param source_control_sync_job_id: The source control sync job id. Required. + :type source_control_sync_job_id: str + :param parameters: The parameters supplied to the create source control sync job operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControlSyncJob or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControlSyncJob + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create( + self, + resource_group_name: str, + automation_account_name: str, + source_control_name: str, + source_control_sync_job_id: str, + parameters: Union[_models.SourceControlSyncJobCreateParameters, IO], + **kwargs: Any + ) -> _models.SourceControlSyncJob: + """Creates the sync job for a source control. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param source_control_name: The source control name. Required. + :type source_control_name: str + :param source_control_sync_job_id: The source control sync job id. Required. + :type source_control_sync_job_id: str + :param parameters: The parameters supplied to the create source control sync job operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.SourceControlSyncJobCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SourceControlSyncJob or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.SourceControlSyncJob + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJob] - _json = self._serialize.body(parameters, 'SourceControlSyncJobCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "SourceControlSyncJobCreateParameters") request = build_create_request( resource_group_name=resource_group_name, @@ -232,7 +304,8 @@ def create( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -240,10 +313,9 @@ def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -251,15 +323,14 @@ def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControlSyncJob', pipeline_response) + deserialized = self._deserialize("SourceControlSyncJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}"} # type: ignore @distributed_trace def get( @@ -272,34 +343,28 @@ def get( ) -> _models.SourceControlSyncJobById: """Retrieve the source control sync job identified by job id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param source_control_sync_job_id: The source control sync job id. + :param source_control_sync_job_id: The source control sync job id. Required. :type source_control_sync_job_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControlSyncJobById, or the result of cls(response) + :return: SourceControlSyncJobById or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControlSyncJobById - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJobById] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJobById] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -307,7 +372,7 @@ def get( source_control_sync_job_id=source_control_sync_job_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -315,10 +380,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -326,15 +390,14 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControlSyncJobById', pipeline_response) + deserialized = self._deserialize("SourceControlSyncJobById", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}"} # type: ignore @distributed_trace def list_by_automation_account( @@ -344,48 +407,43 @@ def list_by_automation_account( source_control_name: str, filter: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.SourceControlSyncJobListResult]: + ) -> Iterable["_models.SourceControlSyncJob"]: """Retrieve a list of source control sync jobs. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SourceControlSyncJobListResult or the result of + :return: An iterator like instance of either SourceControlSyncJob or the result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.SourceControlSyncJobListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.SourceControlSyncJob] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJobListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJobListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, source_control_name=source_control_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -393,18 +451,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - source_control_name=source_control_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -420,10 +467,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -434,8 +479,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_sync_job_streams_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_sync_job_streams_operations.py index 75983d0b9532..2fc86a1641a8 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_sync_job_streams_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_source_control_sync_job_streams_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +24,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_by_sync_job_request( resource_group_name: str, automation_account_name: str, @@ -40,36 +47,35 @@ def build_list_by_sync_job_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "sourceControlSyncJobId": _SERIALIZER.url("source_control_sync_job_id", source_control_sync_job_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "sourceControlSyncJobId": _SERIALIZER.url("source_control_sync_job_id", source_control_sync_job_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( @@ -84,35 +90,35 @@ def build_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams/{streamId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams/{streamId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, 'str'), - "sourceControlSyncJobId": _SERIALIZER.url("source_control_sync_job_id", source_control_sync_job_id, 'str'), - "streamId": _SERIALIZER.url("stream_id", stream_id, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "sourceControlName": _SERIALIZER.url("source_control_name", source_control_name, "str"), + "sourceControlSyncJobId": _SERIALIZER.url("source_control_sync_job_id", source_control_sync_job_id, "str"), + "streamId": _SERIALIZER.url("stream_id", stream_id, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class SourceControlSyncJobStreamsOperations: """ @@ -133,7 +139,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_sync_job( self, @@ -143,51 +148,46 @@ def list_by_sync_job( source_control_sync_job_id: str, filter: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.SourceControlSyncJobStreamsListBySyncJob]: + ) -> Iterable["_models.SourceControlSyncJobStream"]: """Retrieve a list of sync job streams identified by sync job id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param source_control_sync_job_id: The source control sync job id. + :param source_control_sync_job_id: The source control sync job id. Required. :type source_control_sync_job_id: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either SourceControlSyncJobStreamsListBySyncJob or the - result of cls(response) - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.SourceControlSyncJobStreamsListBySyncJob] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either SourceControlSyncJobStream or the result of + cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.SourceControlSyncJobStream] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJobStreamsListBySyncJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJobStreamsListBySyncJob] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_sync_job_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, source_control_name=source_control_name, source_control_sync_job_id=source_control_sync_job_id, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_sync_job.metadata['url'], + api_version=api_version, + template_url=self.list_by_sync_job.metadata["url"], headers=_headers, params=_params, ) @@ -195,19 +195,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_sync_job_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - source_control_name=source_control_name, - source_control_sync_job_id=source_control_sync_job_id, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -223,10 +211,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -237,11 +223,9 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_sync_job.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams"} # type: ignore + list_by_sync_job.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams"} # type: ignore @distributed_trace def get( @@ -255,36 +239,30 @@ def get( ) -> _models.SourceControlSyncJobStreamById: """Retrieve a sync job stream identified by stream id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param source_control_name: The source control name. + :param source_control_name: The source control name. Required. :type source_control_name: str - :param source_control_sync_job_id: The source control sync job id. + :param source_control_sync_job_id: The source control sync job id. Required. :type source_control_sync_job_id: str - :param stream_id: The id of the sync job stream. + :param stream_id: The id of the sync job stream. Required. :type stream_id: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SourceControlSyncJobStreamById, or the result of cls(response) + :return: SourceControlSyncJobStreamById or the result of cls(response) :rtype: ~azure.mgmt.automation.models.SourceControlSyncJobStreamById - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.SourceControlSyncJobStreamById] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.SourceControlSyncJobStreamById] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, @@ -293,7 +271,7 @@ def get( stream_id=stream_id, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -301,10 +279,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -312,12 +289,11 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('SourceControlSyncJobStreamById', pipeline_response) + deserialized = self._deserialize("SourceControlSyncJobStreamById", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams/{streamId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/sourceControls/{sourceControlName}/sourceControlSyncJobs/{sourceControlSyncJobId}/streams/{streamId}"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_statistics_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_statistics_operations.py index 947862ac8877..fa0a69081741 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_statistics_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_statistics_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,13 +24,16 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_by_automation_account_request( resource_group_name: str, automation_account_name: str, @@ -38,34 +45,34 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/statistics") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/statistics", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class StatisticsOperations: """ @@ -86,52 +93,42 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> Iterable[_models.StatisticsListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.Statistics"]: """Retrieve the statistics for the account. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either StatisticsListResult or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.StatisticsListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Statistics or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Statistics] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.StatisticsListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.StatisticsListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -139,17 +136,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -165,10 +152,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -179,8 +164,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/statistics"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/statistics"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_test_job_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_test_job_operations.py index f054aa4ca517..f203735f22e4 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_test_job_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_test_job_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest @@ -19,214 +23,188 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_create_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - *, - json: Optional[_models.TestJobCreateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_resume_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/resume") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/resume", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_stop_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/stop") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/stop", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_suspend_request( - subscription_id: str, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, runbook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/suspend") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/suspend", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class TestJobOperations: """ @@ -247,57 +225,122 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace + @overload def create( self, resource_group_name: str, automation_account_name: str, runbook_name: str, parameters: _models.TestJobCreateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.TestJob: """Create a test job of the runbook. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The parameters supplied to the create test job operation. + :param runbook_name: The parameters supplied to the create test job operation. Required. :type runbook_name: str - :param parameters: The parameters supplied to the create test job operation. + :param parameters: The parameters supplied to the create test job operation. Required. :type parameters: ~azure.mgmt.automation.models.TestJobCreateParameters - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: TestJob or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.TestJob + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.TestJob: + """Create a test job of the runbook. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The parameters supplied to the create test job operation. Required. + :type runbook_name: str + :param parameters: The parameters supplied to the create test job operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: TestJob or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.TestJob + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create( + self, + resource_group_name: str, + automation_account_name: str, + runbook_name: str, + parameters: Union[_models.TestJobCreateParameters, IO], + **kwargs: Any + ) -> _models.TestJob: + """Create a test job of the runbook. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param runbook_name: The parameters supplied to the create test job operation. Required. + :type runbook_name: str + :param parameters: The parameters supplied to the create test job operation. Is either a model + type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.TestJobCreateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: TestJob, or the result of cls(response) + :return: TestJob or the result of cls(response) :rtype: ~azure.mgmt.automation.models.TestJob - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.TestJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.TestJob] - _json = self._serialize.body(parameters, 'TestJobCreateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "TestJobCreateParameters") request = build_create_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, content_type=content_type, json=_json, - template_url=self.create.metadata['url'], + content=_content, + template_url=self.create.metadata["url"], headers=_headers, params=_params, ) @@ -305,10 +348,9 @@ def create( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [201]: @@ -316,59 +358,48 @@ def create( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('TestJob', pipeline_response) + deserialized = self._deserialize("TestJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob"} # type: ignore - + create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> _models.TestJob: """Retrieve the test job for the specified runbook. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: TestJob, or the result of cls(response) + :return: TestJob or the result of cls(response) :rtype: ~azure.mgmt.automation.models.TestJob - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.TestJob] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.TestJob] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -376,10 +407,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -387,59 +417,48 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('TestJob', pipeline_response) + deserialized = self._deserialize("TestJob", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob"} # type: ignore @distributed_trace def resume( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: """Resume the test job. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_resume_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.resume.metadata['url'], + template_url=self.resume.metadata["url"], headers=_headers, params=_params, ) @@ -447,10 +466,9 @@ def resume( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -461,52 +479,41 @@ def resume( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - resume.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/resume"} # type: ignore - + resume.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/resume"} # type: ignore @distributed_trace def stop( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: """Stop the test job. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_stop_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.stop.metadata['url'], + template_url=self.stop.metadata["url"], headers=_headers, params=_params, ) @@ -514,10 +521,9 @@ def stop( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -528,52 +534,41 @@ def stop( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - stop.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/stop"} # type: ignore - + stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/stop"} # type: ignore @distributed_trace def suspend( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - runbook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, runbook_name: str, **kwargs: Any ) -> None: """Suspend the test job. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_suspend_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.suspend.metadata['url'], + template_url=self.suspend.metadata["url"], headers=_headers, params=_params, ) @@ -581,10 +576,9 @@ def suspend( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -595,5 +589,4 @@ def suspend( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - suspend.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/suspend"} # type: ignore - + suspend.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/suspend"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_test_job_streams_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_test_job_streams_operations.py index da1b8f721834..1560fba948c7 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_test_job_streams_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_test_job_streams_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,59 +24,61 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_get_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, runbook_name: str, job_stream_id: str, + subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams/{jobStreamId}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams/{jobStreamId}", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), - "jobStreamId": _SERIALIZER.url("job_stream_id", job_stream_id, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), + "jobStreamId": _SERIALIZER.url("job_stream_id", job_stream_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_test_job_request( - subscription_id: str, resource_group_name: str, automation_account_name: str, runbook_name: str, + subscription_id: str, *, filter: Optional[str] = None, **kwargs: Any @@ -80,35 +86,35 @@ def build_list_by_test_job_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams", + ) # pylint: disable=line-too-long path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "runbookName": _SERIALIZER.url("runbook_name", runbook_name, 'str'), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "runbookName": _SERIALIZER.url("runbook_name", runbook_name, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class TestJobStreamsOperations: """ @@ -129,7 +135,6 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def get( self, @@ -141,42 +146,36 @@ def get( ) -> _models.JobStream: """Retrieve a test job stream of the test job identified by runbook name and stream id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str - :param job_stream_id: The job stream id. + :param job_stream_id: The job stream id. Required. :type job_stream_id: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: JobStream, or the result of cls(response) + :return: JobStream or the result of cls(response) :rtype: ~azure.mgmt.automation.models.JobStream - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStream] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStream] - request = build_get_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, job_stream_id=job_stream_id, + subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -184,10 +183,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -195,15 +193,14 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('JobStream', pipeline_response) + deserialized = self._deserialize("JobStream", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams/{jobStreamId}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams/{jobStreamId}"} # type: ignore @distributed_trace def list_by_test_job( @@ -213,46 +210,42 @@ def list_by_test_job( runbook_name: str, filter: Optional[str] = None, **kwargs: Any - ) -> Iterable[_models.JobStreamListResult]: + ) -> Iterable["_models.JobStream"]: """Retrieve a list of test job streams identified by runbook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param runbook_name: The runbook name. + :param runbook_name: The runbook name. Required. :type runbook_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2018-06-30". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either JobStreamListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.JobStreamListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either JobStream or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.JobStream] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2018-06-30")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.JobStreamListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.JobStreamListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_test_job_request( - subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, automation_account_name=automation_account_name, runbook_name=runbook_name, - api_version=api_version, + subscription_id=self._config.subscription_id, filter=filter, - template_url=self.list_by_test_job.metadata['url'], + api_version=api_version, + template_url=self.list_by_test_job.metadata["url"], headers=_headers, params=_params, ) @@ -260,18 +253,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_test_job_request( - subscription_id=self._config.subscription_id, - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - runbook_name=runbook_name, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -287,10 +269,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -301,8 +281,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_test_job.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams"} # type: ignore + list_by_test_job.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/runbooks/{runbookName}/draft/testJob/streams"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_usages_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_usages_operations.py index addb816185ae..c356702bf337 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_usages_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_usages_operations.py @@ -8,9 +8,13 @@ # -------------------------------------------------------------------------- from typing import Any, Callable, Dict, Iterable, Optional, TypeVar -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,48 +24,48 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/usages") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/usages", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class UsagesOperations: """ @@ -82,47 +86,39 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.UsageListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Usage"]: """Retrieve the usage for the account id. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2021-06-22". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either UsageListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.UsageListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Usage or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Usage] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2021-06-22")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.UsageListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.UsageListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -130,16 +126,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -155,10 +142,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -169,8 +154,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/usages"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/usages"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_variable_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_variable_operations.py index 16b0dc2ce4ed..490cd85f5448 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_variable_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_variable_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,220 +24,190 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - variable_name: str, - subscription_id: str, - *, - json: Optional[_models.VariableCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, variable_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "variableName": _SERIALIZER.url("variable_name", variable_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "variableName": _SERIALIZER.url("variable_name", variable_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - variable_name: str, - subscription_id: str, - *, - json: Optional[_models.VariableUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, variable_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "variableName": _SERIALIZER.url("variable_name", variable_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "variableName": _SERIALIZER.url("variable_name", variable_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_delete_request( - resource_group_name: str, - automation_account_name: str, - variable_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, variable_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "variableName": _SERIALIZER.url("variable_name", variable_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "variableName": _SERIALIZER.url("variable_name", variable_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - variable_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, variable_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "variableName": _SERIALIZER.url("variable_name", variable_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "variableName": _SERIALIZER.url("variable_name", variable_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-08-08")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class VariableOperations: """ @@ -254,47 +228,113 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, variable_name: str, parameters: _models.VariableCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Variable: """Create a variable. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param variable_name: The variable name. + :param variable_name: The variable name. Required. :type variable_name: str :param parameters: The parameters supplied to the create or update variable operation. + Required. :type parameters: ~azure.mgmt.automation.models.VariableCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Variable or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Variable + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + variable_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Variable: + """Create a variable. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param variable_name: The variable name. Required. + :type variable_name: str + :param parameters: The parameters supplied to the create or update variable operation. + Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Variable or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Variable + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + variable_name: str, + parameters: Union[_models.VariableCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Variable: + """Create a variable. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param variable_name: The variable name. Required. + :type variable_name: str + :param parameters: The parameters supplied to the create or update variable operation. Is + either a model type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.VariableCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Variable, or the result of cls(response) + :return: Variable or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Variable - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Variable] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Variable] - _json = self._serialize.body(parameters, 'VariableCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VariableCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -304,7 +344,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -312,10 +353,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -324,59 +364,123 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Variable', pipeline_response) + deserialized = self._deserialize("Variable", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Variable', pipeline_response) + deserialized = self._deserialize("Variable", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, variable_name: str, parameters: _models.VariableUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Variable: """Update a variable. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param variable_name: The variable name. + :param variable_name: The variable name. Required. :type variable_name: str - :param parameters: The parameters supplied to the update variable operation. + :param parameters: The parameters supplied to the update variable operation. Required. :type parameters: ~azure.mgmt.automation.models.VariableUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Variable or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Variable + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + variable_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Variable: + """Update a variable. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param variable_name: The variable name. Required. + :type variable_name: str + :param parameters: The parameters supplied to the update variable operation. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Variable, or the result of cls(response) + :return: Variable or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Variable - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + variable_name: str, + parameters: Union[_models.VariableUpdateParameters, IO], + **kwargs: Any + ) -> _models.Variable: + """Update a variable. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param variable_name: The variable name. Required. + :type variable_name: str + :param parameters: The parameters supplied to the update variable operation. Is either a model + type or a IO type. Required. + :type parameters: ~azure.mgmt.automation.models.VariableUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Variable or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Variable + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Variable] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Variable] - _json = self._serialize.body(parameters, 'VariableUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "VariableUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -386,7 +490,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -394,10 +499,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -405,59 +509,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Variable', pipeline_response) + deserialized = self._deserialize("Variable", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - variable_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, variable_name: str, **kwargs: Any ) -> None: """Delete the variable. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param variable_name: The name of variable. + :param variable_name: The name of variable. Required. :type variable_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, variable_name=variable_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -465,10 +558,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -479,52 +571,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - variable_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, variable_name: str, **kwargs: Any ) -> _models.Variable: """Retrieve the variable identified by variable name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param variable_name: The name of variable. + :param variable_name: The name of variable. Required. :type variable_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Variable, or the result of cls(response) + :return: Variable or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Variable - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Variable] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Variable] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, variable_name=variable_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -532,10 +613,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -543,56 +623,48 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Variable', pipeline_response) + deserialized = self._deserialize("Variable", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables/{variableName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> Iterable[_models.VariableListResult]: + self, resource_group_name: str, automation_account_name: str, **kwargs: Any + ) -> Iterable["_models.Variable"]: """Retrieve a list of variables. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either VariableListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.VariableListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Variable or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Variable] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.VariableListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.VariableListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.list_by_automation_account.metadata['url'], + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -600,16 +672,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -625,10 +688,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -639,8 +700,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/variables"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_watcher_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_watcher_operations.py index 71f7f6bc8ee4..c1353f6f2be4 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_watcher_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_watcher_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,261 +24,224 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - subscription_id: str, - *, - json: Optional[_models.Watcher] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, watcher_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, watcher_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - subscription_id: str, - *, - json: Optional[_models.WatcherUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, watcher_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_delete_request( - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, watcher_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_start_request( - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, watcher_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/start") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/start", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_stop_request( - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, watcher_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/stop") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/stop", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "watcherName": _SERIALIZER.url("watcher_name", watcher_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "watcherName": _SERIALIZER.url("watcher_name", watcher_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -288,34 +255,34 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2020-01-13-preview")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class WatcherOperations: """ @@ -336,47 +303,111 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, watcher_name: str, parameters: _models.Watcher, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Watcher: """Create the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :param parameters: The create or update parameters for watcher. + :param parameters: The create or update parameters for watcher. Required. :type parameters: ~azure.mgmt.automation.models.Watcher - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Watcher, or the result of cls(response) + :return: Watcher or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Watcher - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + watcher_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Watcher: + """Create the watcher identified by watcher name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param watcher_name: The watcher name. Required. + :type watcher_name: str + :param parameters: The create or update parameters for watcher. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + watcher_name: str, + parameters: Union[_models.Watcher, IO], + **kwargs: Any + ) -> _models.Watcher: + """Create the watcher identified by watcher name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param watcher_name: The watcher name. Required. + :type watcher_name: str + :param parameters: The create or update parameters for watcher. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.Watcher or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Watcher] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Watcher] - _json = self._serialize.body(parameters, 'Watcher') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "Watcher") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -386,7 +417,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -394,10 +426,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -406,62 +437,51 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Watcher', pipeline_response) + deserialized = self._deserialize("Watcher", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Watcher', pipeline_response) + deserialized = self._deserialize("Watcher", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, watcher_name: str, **kwargs: Any ) -> _models.Watcher: """Retrieve the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Watcher, or the result of cls(response) + :return: Watcher or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Watcher - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Watcher] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Watcher] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, watcher_name=watcher_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -469,10 +489,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -480,56 +499,120 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Watcher', pipeline_response) + deserialized = self._deserialize("Watcher", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, watcher_name: str, parameters: _models.WatcherUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Watcher: """Update the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :param parameters: The update parameters for watcher. + :param parameters: The update parameters for watcher. Required. :type parameters: ~azure.mgmt.automation.models.WatcherUpdateParameters - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + watcher_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Watcher: + """Update the watcher identified by watcher name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param watcher_name: The watcher name. Required. + :type watcher_name: str + :param parameters: The update parameters for watcher. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Watcher or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Watcher + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + watcher_name: str, + parameters: Union[_models.WatcherUpdateParameters, IO], + **kwargs: Any + ) -> _models.Watcher: + """Update the watcher identified by watcher name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param watcher_name: The watcher name. Required. + :type watcher_name: str + :param parameters: The update parameters for watcher. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.automation.models.WatcherUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Watcher, or the result of cls(response) + :return: Watcher or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Watcher - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Watcher] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Watcher] - _json = self._serialize.body(parameters, 'WatcherUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "WatcherUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -539,7 +622,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -547,10 +631,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -558,59 +641,48 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Watcher', pipeline_response) + deserialized = self._deserialize("Watcher", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, watcher_name: str, **kwargs: Any ) -> None: """Delete the watcher by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, watcher_name=watcher_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -618,10 +690,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -632,52 +703,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}"} # type: ignore @distributed_trace def start( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, watcher_name: str, **kwargs: Any ) -> None: """Resume the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_start_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, watcher_name=watcher_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.start.metadata['url'], + template_url=self.start.metadata["url"], headers=_headers, params=_params, ) @@ -685,10 +745,9 @@ def start( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -699,52 +758,41 @@ def start( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - start.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/start"} # type: ignore - + start.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/start"} # type: ignore @distributed_trace def stop( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - watcher_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, watcher_name: str, **kwargs: Any ) -> None: """Resume the watcher identified by watcher name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param watcher_name: The watcher name. + :param watcher_name: The watcher name. Required. :type watcher_name: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_stop_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, watcher_name=watcher_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.stop.metadata['url'], + template_url=self.stop.metadata["url"], headers=_headers, params=_params, ) @@ -752,10 +800,9 @@ def stop( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -766,53 +813,44 @@ def stop( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - stop.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/stop"} # type: ignore - + stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers/{watcherName}/stop"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> Iterable[_models.WatcherListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.Watcher"]: """Retrieve a list of watchers. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2020-01-13-preview". Note that overriding - this default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either WatcherListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.WatcherListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Watcher or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Watcher] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2020-01-13-preview")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.WatcherListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.WatcherListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -820,17 +858,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -846,10 +874,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -860,8 +886,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/watchers"} # type: ignore diff --git a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_webhook_operations.py b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_webhook_operations.py index 1f8b276de3c9..2f74966c2202 100644 --- a/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_webhook_operations.py +++ b/sdk/automation/azure-mgmt-automation/azure/mgmt/automation/operations/_webhook_operations.py @@ -6,11 +6,15 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Callable, Dict, Iterable, Optional, TypeVar - -from msrest import Serializer - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -20,220 +24,189 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from .. import models as _models +from .._serialization import Serializer from .._vendor import MixinABC, _convert_request, _format_url_section -T = TypeVar('T') + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False + def build_generate_uri_request( - resource_group_name: str, - automation_account_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-10-31")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/generateUri") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/generateUri", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="POST", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_delete_request( - resource_group_name: str, - automation_account_name: str, - webhook_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, webhook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-10-31")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "webhookName": _SERIALIZER.url("webhook_name", webhook_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "webhookName": _SERIALIZER.url("webhook_name", webhook_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="DELETE", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) def build_get_request( - resource_group_name: str, - automation_account_name: str, - webhook_name: str, - subscription_id: str, - **kwargs: Any + resource_group_name: str, automation_account_name: str, webhook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-10-31")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "webhookName": _SERIALIZER.url("webhook_name", webhook_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "webhookName": _SERIALIZER.url("webhook_name", webhook_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) def build_create_or_update_request( - resource_group_name: str, - automation_account_name: str, - webhook_name: str, - subscription_id: str, - *, - json: Optional[_models.WebhookCreateOrUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, webhook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-10-31")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "webhookName": _SERIALIZER.url("webhook_name", webhook_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "webhookName": _SERIALIZER.url("webhook_name", webhook_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PUT", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) def build_update_request( - resource_group_name: str, - automation_account_name: str, - webhook_name: str, - subscription_id: str, - *, - json: Optional[_models.WebhookUpdateParameters] = None, - content: Any = None, - **kwargs: Any + resource_group_name: str, automation_account_name: str, webhook_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-10-31")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "webhookName": _SERIALIZER.url("webhook_name", webhook_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "webhookName": _SERIALIZER.url("webhook_name", webhook_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers if content_type is not None: - _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest( - method="PATCH", - url=_url, - params=_params, - headers=_headers, - json=json, - content=content, - **kwargs - ) + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) def build_list_by_automation_account_request( @@ -247,34 +220,34 @@ def build_list_by_automation_account_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - accept = _headers.pop('Accept', "application/json") + api_version = kwargs.pop("api_version", _params.pop("api-version", "2015-10-31")) # type: str + accept = _headers.pop("Accept", "application/json") # Construct URL - _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks") # pylint: disable=line-too-long + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks", + ) # pylint: disable=line-too-long path_format_arguments = { - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._]+$'), - "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, 'str'), - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'), + "resourceGroupName": _SERIALIZER.url( + "resource_group_name", resource_group_name, "str", max_length=90, min_length=1, pattern=r"^[-\w\._]+$" + ), + "automationAccountName": _SERIALIZER.url("automation_account_name", automation_account_name, "str"), + "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters if filter is not None: - _params['$filter'] = _SERIALIZER.query("filter", filter, 'str') - _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["$filter"] = _SERIALIZER.query("filter", filter, "str") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - return HttpRequest( - method="GET", - url=_url, - params=_params, - headers=_headers, - **kwargs - ) class WebhookOperations: """ @@ -295,46 +268,34 @@ def __init__(self, *args, **kwargs): self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") - @distributed_trace - def generate_uri( - self, - resource_group_name: str, - automation_account_name: str, - **kwargs: Any - ) -> str: + def generate_uri(self, resource_group_name: str, automation_account_name: str, **kwargs: Any) -> str: """Generates a Uri for use in creating a webhook. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: str, or the result of cls(response) + :return: str or the result of cls(response) :rtype: str - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[str] - request = build_generate_uri_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.generate_uri.metadata['url'], + template_url=self.generate_uri.metadata["url"], headers=_headers, params=_params, ) @@ -342,10 +303,9 @@ def generate_uri( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -353,59 +313,48 @@ def generate_uri( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('str', pipeline_response) + deserialized = self._deserialize("str", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - generate_uri.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/generateUri"} # type: ignore - + generate_uri.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/generateUri"} # type: ignore @distributed_trace def delete( # pylint: disable=inconsistent-return-statements - self, - resource_group_name: str, - automation_account_name: str, - webhook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, webhook_name: str, **kwargs: Any ) -> None: """Delete the webhook by name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param webhook_name: The webhook name. + :param webhook_name: The webhook name. Required. :type webhook_name: str - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[None] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_delete_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, webhook_name=webhook_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.delete.metadata['url'], + template_url=self.delete.metadata["url"], headers=_headers, params=_params, ) @@ -413,10 +362,9 @@ def delete( # pylint: disable=inconsistent-return-statements request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -427,52 +375,41 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - + delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore @distributed_trace def get( - self, - resource_group_name: str, - automation_account_name: str, - webhook_name: str, - **kwargs: Any + self, resource_group_name: str, automation_account_name: str, webhook_name: str, **kwargs: Any ) -> _models.Webhook: """Retrieve the webhook identified by webhook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param webhook_name: The webhook name. + :param webhook_name: The webhook name. Required. :type webhook_name: str - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Webhook, or the result of cls(response) + :return: Webhook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Webhook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.Webhook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.Webhook] - request = build_get_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, webhook_name=webhook_name, subscription_id=self._config.subscription_id, api_version=api_version, - template_url=self.get.metadata['url'], + template_url=self.get.metadata["url"], headers=_headers, params=_params, ) @@ -480,10 +417,9 @@ def get( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -491,56 +427,120 @@ def get( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Webhook', pipeline_response) + deserialized = self._deserialize("Webhook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - + get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - @distributed_trace + @overload def create_or_update( self, resource_group_name: str, automation_account_name: str, webhook_name: str, parameters: _models.WebhookCreateOrUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Webhook: """Create the webhook identified by webhook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param webhook_name: The webhook name. + :param webhook_name: The webhook name. Required. :type webhook_name: str - :param parameters: The create or update parameters for webhook. + :param parameters: The create or update parameters for webhook. Required. :type parameters: ~azure.mgmt.automation.models.WebhookCreateOrUpdateParameters - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Webhook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Webhook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + webhook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Webhook: + """Create the webhook identified by webhook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param webhook_name: The webhook name. Required. + :type webhook_name: str + :param parameters: The create or update parameters for webhook. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Webhook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Webhook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + automation_account_name: str, + webhook_name: str, + parameters: Union[_models.WebhookCreateOrUpdateParameters, IO], + **kwargs: Any + ) -> _models.Webhook: + """Create the webhook identified by webhook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param webhook_name: The webhook name. Required. + :type webhook_name: str + :param parameters: The create or update parameters for webhook. Is either a model type or a IO + type. Required. + :type parameters: ~azure.mgmt.automation.models.WebhookCreateOrUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Webhook, or the result of cls(response) + :return: Webhook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Webhook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Webhook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Webhook] - _json = self._serialize.body(parameters, 'WebhookCreateOrUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "WebhookCreateOrUpdateParameters") request = build_create_or_update_request( resource_group_name=resource_group_name, @@ -550,7 +550,8 @@ def create_or_update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.create_or_update.metadata['url'], + content=_content, + template_url=self.create_or_update.metadata["url"], headers=_headers, params=_params, ) @@ -558,10 +559,9 @@ def create_or_update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200, 201]: @@ -570,59 +570,123 @@ def create_or_update( raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) if response.status_code == 200: - deserialized = self._deserialize('Webhook', pipeline_response) + deserialized = self._deserialize("Webhook", pipeline_response) if response.status_code == 201: - deserialized = self._deserialize('Webhook', pipeline_response) + deserialized = self._deserialize("Webhook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore + create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - - @distributed_trace + @overload def update( self, resource_group_name: str, automation_account_name: str, webhook_name: str, parameters: _models.WebhookUpdateParameters, + *, + content_type: str = "application/json", **kwargs: Any ) -> _models.Webhook: """Update the webhook identified by webhook name. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str - :param webhook_name: The webhook name. + :param webhook_name: The webhook name. Required. :type webhook_name: str - :param parameters: The update parameters for webhook. + :param parameters: The update parameters for webhook. Required. :type parameters: ~azure.mgmt.automation.models.WebhookUpdateParameters - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: Webhook, or the result of cls(response) + :return: Webhook or the result of cls(response) :rtype: ~azure.mgmt.automation.models.Webhook - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) + + @overload + def update( + self, + resource_group_name: str, + automation_account_name: str, + webhook_name: str, + parameters: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.Webhook: + """Update the webhook identified by webhook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param webhook_name: The webhook name. Required. + :type webhook_name: str + :param parameters: The update parameters for webhook. Required. + :type parameters: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Webhook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Webhook + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update( + self, + resource_group_name: str, + automation_account_name: str, + webhook_name: str, + parameters: Union[_models.WebhookUpdateParameters, IO], + **kwargs: Any + ) -> _models.Webhook: + """Update the webhook identified by webhook name. + + :param resource_group_name: Name of an Azure Resource group. Required. + :type resource_group_name: str + :param automation_account_name: The name of the automation account. Required. + :type automation_account_name: str + :param webhook_name: The webhook name. Required. + :type webhook_name: str + :param parameters: The update parameters for webhook. Is either a model type or a IO type. + Required. + :type parameters: ~azure.mgmt.automation.models.WebhookUpdateParameters or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: Webhook or the result of cls(response) + :rtype: ~azure.mgmt.automation.models.Webhook + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] - cls = kwargs.pop('cls', None) # type: ClsType[_models.Webhook] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.Webhook] - _json = self._serialize.body(parameters, 'WebhookUpdateParameters') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IO, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "WebhookUpdateParameters") request = build_update_request( resource_group_name=resource_group_name, @@ -632,7 +696,8 @@ def update( api_version=api_version, content_type=content_type, json=_json, - template_url=self.update.metadata['url'], + content=_content, + template_url=self.update.metadata["url"], headers=_headers, params=_params, ) @@ -640,10 +705,9 @@ def update( request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, - stream=False, - **kwargs + request, stream=False, **kwargs ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -651,60 +715,51 @@ def update( error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - deserialized = self._deserialize('Webhook', pipeline_response) + deserialized = self._deserialize("Webhook", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore - + update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks/{webhookName}"} # type: ignore @distributed_trace def list_by_automation_account( - self, - resource_group_name: str, - automation_account_name: str, - filter: Optional[str] = None, - **kwargs: Any - ) -> Iterable[_models.WebhookListResult]: + self, resource_group_name: str, automation_account_name: str, filter: Optional[str] = None, **kwargs: Any + ) -> Iterable["_models.Webhook"]: """Retrieve a list of webhooks. - :param resource_group_name: Name of an Azure Resource group. + :param resource_group_name: Name of an Azure Resource group. Required. :type resource_group_name: str - :param automation_account_name: The name of the automation account. + :param automation_account_name: The name of the automation account. Required. :type automation_account_name: str :param filter: The filter to apply on the operation. Default value is None. :type filter: str - :keyword api_version: Api Version. Default value is "2015-10-31". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either WebhookListResult or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.WebhookListResult] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either Webhook or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.automation.models.Webhook] + :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', _params.pop('api-version', "2015-10-31")) # type: str - cls = kwargs.pop('cls', None) # type: ClsType[_models.WebhookListResult] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.WebhookListResult] + + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {}) or {}) - error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError - } - error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: - + request = build_list_by_automation_account_request( resource_group_name=resource_group_name, automation_account_name=automation_account_name, subscription_id=self._config.subscription_id, - api_version=api_version, filter=filter, - template_url=self.list_by_automation_account.metadata['url'], + api_version=api_version, + template_url=self.list_by_automation_account.metadata["url"], headers=_headers, params=_params, ) @@ -712,17 +767,7 @@ def prepare_request(next_link=None): request.url = self._client.format_url(request.url) # type: ignore else: - - request = build_list_by_automation_account_request( - resource_group_name=resource_group_name, - automation_account_name=automation_account_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - filter=filter, - template_url=next_link, - headers=_headers, - params=_params, - ) + request = HttpRequest("GET", next_link) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" @@ -738,10 +783,8 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access - request, - stream=False, - **kwargs + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -752,8 +795,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_by_automation_account.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks"} # type: ignore + list_by_automation_account.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Automation/automationAccounts/{automationAccountName}/webhooks"} # type: ignore