diff --git a/sdk/datafactory/azure-mgmt-datafactory/_meta.json b/sdk/datafactory/azure-mgmt-datafactory/_meta.json index 39595f759369..69699edfe235 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/_meta.json +++ b/sdk/datafactory/azure-mgmt-datafactory/_meta.json @@ -1,11 +1,11 @@ { - "commit": "21426cf85836ec17aaa4f20f58324a8666925e34", + "commit": "1a7ed23039d926c3d4fe77008e300d653e41602e", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "autorest": "3.9.2", "use": [ - "@autorest/python@6.2.1", + "@autorest/python@6.2.7", "@autorest/modelerfour@4.24.3" ], - "autorest_command": "autorest specification/datafactory/resource-manager/readme.md --generate-sample=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/home/vsts/work/1/azure-sdk-for-python/sdk --use=@autorest/python@6.2.1 --use=@autorest/modelerfour@4.24.3 --version=3.9.2 --version-tolerant=False", + "autorest_command": "autorest specification/datafactory/resource-manager/readme.md --generate-sample=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.2.7 --use=@autorest/modelerfour@4.24.3 --version=3.9.2 --version-tolerant=False", "readme": "specification/datafactory/resource-manager/readme.md" } \ No newline at end of file diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/__init__.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/__init__.py index 0092f7b2e80a..e3b2bfa87ed4 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/__init__.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/__init__.py @@ -13,7 +13,7 @@ try: from ._patch import __all__ as _patch_all - from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import + from ._patch import * # pylint: disable=unused-wildcard-import except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_configuration.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_configuration.py index 155fcc1b1081..d10dbe995788 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_configuration.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_configuration.py @@ -42,7 +42,7 @@ class DataFactoryManagementClientConfiguration(Configuration): # pylint: disabl def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None: super(DataFactoryManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop("api_version", "2018-06-01") # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", "2018-06-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") @@ -56,10 +56,7 @@ def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs kwargs.setdefault("sdk_moniker", "mgmt-datafactory/{}".format(VERSION)) self._configure(**kwargs) - def _configure( - self, **kwargs # type: Any - ): - # type: (...) -> None + 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) diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_data_factory_management_client.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_data_factory_management_client.py index 5273db8e5820..777a8d3adfd0 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_data_factory_management_client.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_data_factory_management_client.py @@ -12,11 +12,12 @@ from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient -from . import models +from . import models as _models from ._configuration import DataFactoryManagementClientConfiguration from ._serialization import Deserializer, Serializer from .operations import ( ActivityRunsOperations, + CredentialOperationsOperations, DataFlowDebugSessionOperations, DataFlowsOperations, DatasetsOperations, @@ -88,6 +89,9 @@ class DataFactoryManagementClient: # pylint: disable=client-accepts-api-version :ivar managed_private_endpoints: ManagedPrivateEndpointsOperations operations :vartype managed_private_endpoints: azure.mgmt.datafactory.operations.ManagedPrivateEndpointsOperations + :ivar credential_operations: CredentialOperationsOperations operations + :vartype credential_operations: + azure.mgmt.datafactory.operations.CredentialOperationsOperations :ivar private_end_point_connections: PrivateEndPointConnectionsOperations operations :vartype private_end_point_connections: azure.mgmt.datafactory.operations.PrivateEndPointConnectionsOperations @@ -124,7 +128,7 @@ def __init__( ) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs) - client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} + client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False @@ -159,6 +163,9 @@ def __init__( self.managed_private_endpoints = ManagedPrivateEndpointsOperations( self._client, self._config, self._serialize, self._deserialize ) + self.credential_operations = CredentialOperationsOperations( + self._client, self._config, self._serialize, self._deserialize + ) self.private_end_point_connections = PrivateEndPointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) @@ -194,15 +201,12 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: request_copy.url = self._client.format_url(request_copy.url) return self._client.send_request(request_copy, **kwargs) - def close(self): - # type: () -> None + def close(self) -> None: self._client.close() - def __enter__(self): - # type: () -> DataFactoryManagementClient + def __enter__(self) -> "DataFactoryManagementClient": self._client.__enter__() return self - def __exit__(self, *exc_details): - # type: (Any) -> None + def __exit__(self, *exc_details) -> None: self._client.__exit__(*exc_details) diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_serialization.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_serialization.py index 7c1dedb5133d..2c170e28dbca 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_serialization.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_serialization.py @@ -25,6 +25,7 @@ # -------------------------------------------------------------------------- # pylint: skip-file +# pyright: reportUnnecessaryTypeIgnoreComment=false from base64 import b64decode, b64encode import calendar @@ -37,24 +38,22 @@ import re import sys import codecs +from typing import Optional, Union, AnyStr, IO, Mapping try: from urllib import quote # type: ignore except ImportError: - from urllib.parse import quote # type: ignore + from urllib.parse import quote import xml.etree.ElementTree as ET -import isodate +import isodate # type: ignore -from typing import Dict, Any, cast, TYPE_CHECKING +from typing import Dict, Any, cast 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: @@ -65,8 +64,7 @@ class RawDeserializer: CONTEXT_NAME = "deserialized_data" @classmethod - def deserialize_from_text(cls, data, content_type=None): - # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> Any + def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: Optional[str] = None) -> Any: """Decode data according to content-type. Accept a stream of data as well, but will be load at once in memory for now. @@ -132,8 +130,7 @@ def _json_attemp(data): 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 + def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], headers: Mapping) -> Any: """Deserialize from HTTP response. Use bytes and headers to NOT use any requests/aiohttp or whatever @@ -160,8 +157,8 @@ def deserialize_from_http_generics(cls, body_bytes, headers): basestring # type: ignore unicode_str = unicode # type: ignore except NameError: - basestring = str # type: ignore - unicode_str = str # type: ignore + basestring = str + unicode_str = str _LOGGER = logging.getLogger(__name__) @@ -188,7 +185,7 @@ def dst(self, dt): try: - from datetime import timezone as _FixedOffset + from datetime import timezone as _FixedOffset # type: ignore except ImportError: # Python 2.7 class _FixedOffset(datetime.tzinfo): # type: ignore @@ -219,7 +216,7 @@ def __getinitargs__(self): try: from datetime import timezone - TZ_UTC = timezone.utc # type: ignore + TZ_UTC = timezone.utc except ImportError: TZ_UTC = UTC() # type: ignore @@ -276,9 +273,9 @@ class Model(object): serialization and deserialization. """ - _subtype_map = {} # type: Dict[str, Dict[str, Any]] - _attribute_map = {} # type: Dict[str, Dict[str, Any]] - _validation = {} # type: Dict[str, Dict[str, Any]] + _subtype_map: Dict[str, Dict[str, Any]] = {} + _attribute_map: Dict[str, Dict[str, Any]] = {} + _validation: Dict[str, Dict[str, Any]] = {} def __init__(self, **kwargs): self.additional_properties = {} @@ -310,7 +307,7 @@ def enable_additional_properties_sending(cls): @classmethod def is_xml_model(cls): try: - cls._xml_map + cls._xml_map # type: ignore except AttributeError: return False return True @@ -319,7 +316,7 @@ def is_xml_model(cls): def _create_xml_node(cls): """Create XML node.""" try: - xml_map = cls._xml_map + xml_map = cls._xml_map # type: ignore except AttributeError: xml_map = {} @@ -453,7 +450,7 @@ def _classify(cls, response, objects): return cls flatten_mapping_type = cls._flatten_subtype(subtype_key, objects) try: - return objects[flatten_mapping_type[subtype_value]] + return objects[flatten_mapping_type[subtype_value]] # type: ignore except KeyError: _LOGGER.warning( "Subtype value %s has no mapping, use base class %s.", @@ -606,13 +603,13 @@ def _serialize(self, target_obj, data_type=None, **kwargs): if xml_ns: ET.register_namespace(xml_prefix, xml_ns) xml_name = "{}{}".format(xml_ns, xml_name) - serialized.set(xml_name, new_attr) + serialized.set(xml_name, new_attr) # type: ignore continue if xml_desc.get("text", False): - serialized.text = new_attr + serialized.text = new_attr # type: ignore continue if isinstance(new_attr, list): - serialized.extend(new_attr) + serialized.extend(new_attr) # type: ignore 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", {}): @@ -621,23 +618,23 @@ def _serialize(self, target_obj, data_type=None, **kwargs): new_attr.tag = "}".join([splitted_tag[0], xml_name]) else: new_attr.tag = xml_name - serialized.append(new_attr) + serialized.append(new_attr) # type: ignore 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) + serialized.append(local_node) # type: ignore else: # JSON - for k in reversed(keys): + for k in reversed(keys): # type: ignore unflattened = {k: new_attr} new_attr = unflattened _new_attr = new_attr _serialized = serialized - for k in keys: + for k in keys: # type: ignore if k not in _serialized: - _serialized.update(_new_attr) - _new_attr = _new_attr[k] + _serialized.update(_new_attr) # type: ignore + _new_attr = _new_attr[k] # type: ignore _serialized = _serialized[k] except ValueError: continue @@ -675,7 +672,7 @@ def body(self, data, data_type, **kwargs): # We're not able to deal with additional properties for now. deserializer.additional_properties_detection = False if is_xml_model_serialization: - deserializer.key_extractors = [ + deserializer.key_extractors = [ # type: ignore attribute_key_case_insensitive_extractor, ] else: @@ -843,7 +840,7 @@ def serialize_unicode(cls, data): pass try: - if isinstance(data, unicode): + if isinstance(data, unicode): # type: ignore # Don't change it, JSON and XML ElementTree are totally able # to serialize correctly u'' strings return data @@ -1001,10 +998,10 @@ def serialize_enum(attr, enum_obj=None): except AttributeError: result = attr try: - enum_obj(result) + enum_obj(result) # type: ignore return result except ValueError: - for enum_value in enum_obj: + for enum_value in enum_obj: # type: ignore if enum_value.value.lower() == str(attr).lower(): return enum_value.value error = "{!r} is not valid value for enum {!r}" @@ -1416,7 +1413,7 @@ def _deserialize(self, target_obj, data): if data is None: return data try: - attributes = response._attribute_map + attributes = response._attribute_map # type: ignore d_attrs = {} for attr, attr_desc in attributes.items(): # Check empty string. If it's not empty, someone has a real "additionalProperties"... @@ -1444,7 +1441,7 @@ def _deserialize(self, target_obj, data): 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 + msg = "Unable to deserialize to object: " + class_name # type: ignore raise_with_traceback(DeserializationError, msg, err) else: additional_properties = self._build_additional_properties(attributes, data) @@ -1543,7 +1540,7 @@ def _unpack_content(raw_data, content_type=None): 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 RawDeserializer.deserialize_from_text(raw_data, content_type) # type: ignore return raw_data def _instantiate_model(self, response, attrs, additional_properties=None): @@ -1565,7 +1562,7 @@ def _instantiate_model(self, response, attrs, additional_properties=None): response_obj.additional_properties = additional_properties return response_obj except TypeError as err: - msg = "Unable to deserialize {} into model {}. ".format(kwargs, response) + msg = "Unable to deserialize {} into model {}. ".format(kwargs, response) # type: ignore raise DeserializationError(msg + str(err)) else: try: @@ -1747,7 +1744,7 @@ def deserialize_unicode(data): # Consider this is real string try: - if isinstance(data, unicode): + if isinstance(data, unicode): # type: ignore return data except NameError: return str(data) @@ -1798,7 +1795,7 @@ def deserialize_bytearray(attr): """ if isinstance(attr, ET.Element): attr = attr.text - return bytearray(b64decode(attr)) + return bytearray(b64decode(attr)) # type: ignore @staticmethod def deserialize_base64(attr): @@ -1810,8 +1807,8 @@ def deserialize_base64(attr): """ if isinstance(attr, ET.Element): attr = attr.text - padding = "=" * (3 - (len(attr) + 3) % 4) - attr = attr + padding + padding = "=" * (3 - (len(attr) + 3) % 4) # type: ignore + attr = attr + padding # type: ignore encoded = attr.replace("-", "+").replace("_", "/") return b64decode(encoded) @@ -1826,7 +1823,7 @@ def deserialize_decimal(attr): if isinstance(attr, ET.Element): attr = attr.text try: - return decimal.Decimal(attr) + return decimal.Decimal(attr) # type: ignore except decimal.DecimalException as err: msg = "Invalid decimal {}".format(attr) raise_with_traceback(DeserializationError, msg, err) @@ -1841,7 +1838,7 @@ def deserialize_long(attr): """ if isinstance(attr, ET.Element): attr = attr.text - return _long_type(attr) + return _long_type(attr) # type: ignore @staticmethod def deserialize_duration(attr): @@ -1871,7 +1868,7 @@ def deserialize_date(attr): """ if isinstance(attr, ET.Element): attr = attr.text - if re.search(r"[^\W\d_]", attr, re.I + re.U): + if re.search(r"[^\W\d_]", attr, re.I + re.U): # type: ignore 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) @@ -1886,7 +1883,7 @@ def deserialize_time(attr): """ if isinstance(attr, ET.Element): attr = attr.text - if re.search(r"[^\W\d_]", attr, re.I + re.U): + if re.search(r"[^\W\d_]", attr, re.I + re.U): # type: ignore raise DeserializationError("Date must have only digits and -. Received: %s" % attr) return isodate.parse_time(attr) @@ -1901,7 +1898,7 @@ def deserialize_rfc(attr): if isinstance(attr, ET.Element): attr = attr.text try: - parsed_date = email.utils.parsedate_tz(attr) + parsed_date = email.utils.parsedate_tz(attr) # type: ignore date_obj = datetime.datetime( *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60)) ) @@ -1924,7 +1921,7 @@ def deserialize_iso(attr): if isinstance(attr, ET.Element): attr = attr.text try: - attr = attr.upper() + attr = attr.upper() # type: ignore match = Deserializer.valid_date.match(attr) if not match: raise ValueError("Invalid datetime string: " + attr) @@ -1960,7 +1957,7 @@ def deserialize_unix(attr): :raises: DeserializationError if format invalid """ if isinstance(attr, ET.Element): - attr = int(attr.text) + attr = int(attr.text) # type: ignore try: date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC) except ValueError as err: diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_version.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_version.py index 64325963654f..c47f66669f1b 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_version.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "2.10.0" +VERSION = "1.0.0" diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/__init__.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/__init__.py index 0a004d7ffed4..18f7efaa68a7 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/__init__.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/__init__.py @@ -10,7 +10,7 @@ try: from ._patch import __all__ as _patch_all - from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import + from ._patch import * # pylint: disable=unused-wildcard-import except ImportError: _patch_all = [] from ._patch import patch_sdk as _patch_sdk diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/_configuration.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/_configuration.py index 8187d4c7ad06..d157b8f5b7e0 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/_configuration.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/_configuration.py @@ -42,7 +42,7 @@ class DataFactoryManagementClientConfiguration(Configuration): # pylint: disabl def __init__(self, credential: "AsyncTokenCredential", subscription_id: str, **kwargs: Any) -> None: super(DataFactoryManagementClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop("api_version", "2018-06-01") # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", "2018-06-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/_data_factory_management_client.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/_data_factory_management_client.py index 6892262f9226..66a7cf514d5d 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/_data_factory_management_client.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/_data_factory_management_client.py @@ -12,11 +12,12 @@ from azure.core.rest import AsyncHttpResponse, HttpRequest from azure.mgmt.core import AsyncARMPipelineClient -from .. import models +from .. import models as _models from .._serialization import Deserializer, Serializer from ._configuration import DataFactoryManagementClientConfiguration from .operations import ( ActivityRunsOperations, + CredentialOperationsOperations, DataFlowDebugSessionOperations, DataFlowsOperations, DatasetsOperations, @@ -89,6 +90,9 @@ class DataFactoryManagementClient: # pylint: disable=client-accepts-api-version :ivar managed_private_endpoints: ManagedPrivateEndpointsOperations operations :vartype managed_private_endpoints: azure.mgmt.datafactory.aio.operations.ManagedPrivateEndpointsOperations + :ivar credential_operations: CredentialOperationsOperations operations + :vartype credential_operations: + azure.mgmt.datafactory.aio.operations.CredentialOperationsOperations :ivar private_end_point_connections: PrivateEndPointConnectionsOperations operations :vartype private_end_point_connections: azure.mgmt.datafactory.aio.operations.PrivateEndPointConnectionsOperations @@ -125,7 +129,7 @@ def __init__( ) self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs) - client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} + client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False @@ -160,6 +164,9 @@ def __init__( self.managed_private_endpoints = ManagedPrivateEndpointsOperations( self._client, self._config, self._serialize, self._deserialize ) + self.credential_operations = CredentialOperationsOperations( + self._client, self._config, self._serialize, self._deserialize + ) self.private_end_point_connections = PrivateEndPointConnectionsOperations( self._client, self._config, self._serialize, self._deserialize ) diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/__init__.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/__init__.py index a20c42cd8bfb..b4c9fa93e0a9 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/__init__.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/__init__.py @@ -23,13 +23,14 @@ from ._data_flow_debug_session_operations import DataFlowDebugSessionOperations from ._managed_virtual_networks_operations import ManagedVirtualNetworksOperations from ._managed_private_endpoints_operations import ManagedPrivateEndpointsOperations +from ._credential_operations_operations import CredentialOperationsOperations from ._private_end_point_connections_operations import PrivateEndPointConnectionsOperations from ._private_endpoint_connection_operations import PrivateEndpointConnectionOperations from ._private_link_resources_operations import PrivateLinkResourcesOperations from ._global_parameters_operations import GlobalParametersOperations from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import * # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -50,6 +51,7 @@ "DataFlowDebugSessionOperations", "ManagedVirtualNetworksOperations", "ManagedPrivateEndpointsOperations", + "CredentialOperationsOperations", "PrivateEndPointConnectionsOperations", "PrivateEndpointConnectionOperations", "PrivateLinkResourcesOperations", diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_activity_runs_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_activity_runs_operations.py index 8b4172800cb2..6ea440d91a2d 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_activity_runs_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_activity_runs_operations.py @@ -154,11 +154,11 @@ async def query_by_pipeline_run( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ActivityRunsQueryResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ActivityRunsQueryResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -182,9 +182,9 @@ async def query_by_pipeline_run( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -201,4 +201,6 @@ async def query_by_pipeline_run( return deserialized - query_by_pipeline_run.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}/queryActivityruns"} # type: ignore + query_by_pipeline_run.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}/queryActivityruns" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_credential_operations_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_credential_operations_operations.py new file mode 100644 index 000000000000..85cef3964cac --- /dev/null +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_credential_operations_operations.py @@ -0,0 +1,462 @@ +# 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. +# -------------------------------------------------------------------------- +import sys +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +import urllib.parse + +from azure.core.async_paging import AsyncItemPaged, AsyncList +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + 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._credential_operations_operations import ( + build_create_or_update_request, + build_delete_request, + build_get_request, + build_list_by_factory_request, +) + +if sys.version_info >= (3, 8): + from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +else: + from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class CredentialOperationsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.datafactory.aio.DataFactoryManagementClient`'s + :attr:`credential_operations` 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 + def list_by_factory( + self, resource_group_name: str, factory_name: str, **kwargs: Any + ) -> AsyncIterable["_models.ManagedIdentityCredentialResource"]: + """List credentials. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: An iterator like instance of either ManagedIdentityCredentialResource or the result of + cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: Literal["2018-06-01"] = kwargs.pop( + "api_version", _params.pop("api-version", self._config.api_version) + ) + cls: ClsType[_models.CredentialListResponse] = kwargs.pop("cls", None) + + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + request = build_list_by_factory_request( + resource_group_name=resource_group_name, + factory_name=factory_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.list_by_factory.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) + request.method = "GET" + return request + + async def extract_data(pipeline_response): + deserialized = self._deserialize("CredentialListResponse", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + request = prepare_request(next_link) + + pipeline_response: PipelineResponse = await self._client._pipeline.run( # 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) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + return pipeline_response + + return AsyncItemPaged(get_next, extract_data) + + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials" + } + + @overload + async def create_or_update( + self, + resource_group_name: str, + factory_name: str, + credential_name: str, + credential: _models.ManagedIdentityCredentialResource, + if_match: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ManagedIdentityCredentialResource: + """Creates or updates a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_name: str + :param credential: Credential resource definition. Required. + :type credential: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource + :param if_match: ETag of the credential entity. Should only be specified for update, for which + it should match existing entity or can be * for unconditional update. Default value is None. + :type if_match: 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: ManagedIdentityCredentialResource or the result of cls(response) + :rtype: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_or_update( + self, + resource_group_name: str, + factory_name: str, + credential_name: str, + credential: IO, + if_match: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ManagedIdentityCredentialResource: + """Creates or updates a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_name: str + :param credential: Credential resource definition. Required. + :type credential: IO + :param if_match: ETag of the credential entity. Should only be specified for update, for which + it should match existing entity or can be * for unconditional update. Default value is None. + :type if_match: 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: ManagedIdentityCredentialResource or the result of cls(response) + :rtype: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_or_update( + self, + resource_group_name: str, + factory_name: str, + credential_name: str, + credential: Union[_models.ManagedIdentityCredentialResource, IO], + if_match: Optional[str] = None, + **kwargs: Any + ) -> _models.ManagedIdentityCredentialResource: + """Creates or updates a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_name: str + :param credential: Credential resource definition. Is either a model type or a IO type. + Required. + :type credential: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource or IO + :param if_match: ETag of the credential entity. Should only be specified for update, for which + it should match existing entity or can be * for unconditional update. Default value is None. + :type if_match: 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: ManagedIdentityCredentialResource or the result of cls(response) + :rtype: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + 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: Literal["2018-06-01"] = kwargs.pop( + "api_version", _params.pop("api-version", self._config.api_version) + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ManagedIdentityCredentialResource] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(credential, (IO, bytes)): + _content = credential + else: + _json = self._serialize.body(credential, "ManagedIdentityCredentialResource") + + request = build_create_or_update_request( + resource_group_name=resource_group_name, + factory_name=factory_name, + credential_name=credential_name, + subscription_id=self._config.subscription_id, + if_match=if_match, + 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) + + pipeline_response: PipelineResponse = await self._client._pipeline.run( # 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) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + deserialized = self._deserialize("ManagedIdentityCredentialResource", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}" + } + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + factory_name: str, + credential_name: str, + if_none_match: Optional[str] = None, + **kwargs: Any + ) -> Optional[_models.ManagedIdentityCredentialResource]: + """Gets a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_name: str + :param if_none_match: ETag of the credential entity. Should only be specified for get. If the + ETag matches the existing entity tag, or if * was provided, then no content will be returned. + Default value is None. + :type if_none_match: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: ManagedIdentityCredentialResource or None or the result of cls(response) + :rtype: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource or None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: Literal["2018-06-01"] = kwargs.pop( + "api_version", _params.pop("api-version", self._config.api_version) + ) + cls: ClsType[Optional[_models.ManagedIdentityCredentialResource]] = kwargs.pop("cls", None) + + request = build_get_request( + resource_group_name=resource_group_name, + factory_name=factory_name, + credential_name=credential_name, + subscription_id=self._config.subscription_id, + if_none_match=if_none_match, + 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) + + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 304]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize("ManagedIdentityCredentialResource", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}" + } + + @distributed_trace_async + async def delete( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, factory_name: str, credential_name: str, **kwargs: Any + ) -> None: + """Deletes a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_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, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: Literal["2018-06-01"] = kwargs.pop( + "api_version", _params.pop("api-version", self._config.api_version) + ) + cls: ClsType[None] = kwargs.pop("cls", None) + + request = build_delete_request( + resource_group_name=resource_group_name, + factory_name=factory_name, + credential_name=credential_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) + + pipeline_response: PipelineResponse = await self._client._pipeline.run( # 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) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) + + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_data_flow_debug_session_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_data_flow_debug_session_operations.py index 88d775f8042f..1547a8f63bcd 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_data_flow_debug_session_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_data_flow_debug_session_operations.py @@ -84,11 +84,11 @@ async def _create_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.CreateDataFlowDebugSessionResponse]] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Optional[_models.CreateDataFlowDebugSessionResponse]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -111,9 +111,9 @@ async def _create_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -136,7 +136,9 @@ async def _create_initial( return deserialized - _create_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession"} # type: ignore + _create_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession" + } @overload async def begin_create( @@ -247,16 +249,16 @@ async def begin_create( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.CreateDataFlowDebugSessionResponse] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.CreateDataFlowDebugSessionResponse] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = await self._create_initial( # type: ignore + raw_result = await self._create_initial( resource_group_name=resource_group_name, factory_name=factory_name, request=request, @@ -276,7 +278,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -288,9 +290,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession"} # type: ignore + begin_create.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession" + } @distributed_trace def query_by_factory( @@ -312,10 +316,10 @@ def query_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.QueryDataFlowDebugSessionsResponse] + ) + cls: ClsType[_models.QueryDataFlowDebugSessionsResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -338,7 +342,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -354,7 +358,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -362,13 +366,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("QueryDataFlowDebugSessionsResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -381,7 +385,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - query_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryDataFlowDebugSessions"} # type: ignore + query_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryDataFlowDebugSessions" + } @overload async def add_data_flow( @@ -473,11 +479,11 @@ async def add_data_flow( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.AddDataFlowToDebugSessionResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.AddDataFlowToDebugSessionResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -500,9 +506,9 @@ async def add_data_flow( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -519,7 +525,9 @@ async def add_data_flow( return deserialized - add_data_flow.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/addDataFlowToDebugSession"} # type: ignore + add_data_flow.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/addDataFlowToDebugSession" + } @overload async def delete( # pylint: disable=inconsistent-return-statements @@ -611,11 +619,11 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[None] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -638,9 +646,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -653,7 +661,9 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/deleteDataFlowDebugSession"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/deleteDataFlowDebugSession" + } async def _execute_command_initial( self, @@ -673,11 +683,11 @@ async def _execute_command_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.DataFlowDebugCommandResponse]] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Optional[_models.DataFlowDebugCommandResponse]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -700,9 +710,9 @@ async def _execute_command_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -725,7 +735,9 @@ async def _execute_command_initial( return deserialized - _execute_command_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/executeDataFlowDebugCommand"} # type: ignore + _execute_command_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/executeDataFlowDebugCommand" + } @overload async def begin_execute_command( @@ -836,16 +848,16 @@ async def begin_execute_command( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DataFlowDebugCommandResponse] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.DataFlowDebugCommandResponse] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = await self._execute_command_initial( # type: ignore + raw_result = await self._execute_command_initial( resource_group_name=resource_group_name, factory_name=factory_name, request=request, @@ -865,7 +877,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -877,6 +889,8 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_execute_command.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/executeDataFlowDebugCommand"} # type: ignore + begin_execute_command.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/executeDataFlowDebugCommand" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_data_flows_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_data_flows_operations.py index be5fd2d8173d..1cc776b42666 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_data_flows_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_data_flows_operations.py @@ -173,11 +173,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DataFlowResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.DataFlowResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -202,9 +202,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -221,7 +221,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}" + } @distributed_trace_async async def get( @@ -260,10 +262,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DataFlowResource] + ) + cls: ClsType[_models.DataFlowResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -277,9 +279,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -296,7 +298,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -326,10 +330,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -342,9 +346,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -357,7 +361,9 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}" + } @distributed_trace def list_by_factory( @@ -378,10 +384,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DataFlowListResponse] + ) + cls: ClsType[_models.DataFlowListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -404,7 +410,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -420,7 +426,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -428,13 +434,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("DataFlowListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -447,4 +453,6 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_datasets_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_datasets_operations.py index 72a996fbebf2..18aa7dbf59f8 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_datasets_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_datasets_operations.py @@ -81,10 +81,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DatasetListResponse] + ) + cls: ClsType[_models.DatasetListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -107,7 +107,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -123,7 +123,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -131,13 +131,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("DatasetListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -150,7 +150,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets" + } @overload async def create_or_update( @@ -262,11 +264,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DatasetResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.DatasetResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -291,9 +293,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -310,7 +312,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}" + } @distributed_trace_async async def get( @@ -349,10 +353,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.DatasetResource]] + ) + cls: ClsType[Optional[_models.DatasetResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -366,9 +370,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -387,7 +391,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -417,10 +423,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -433,9 +439,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -448,4 +454,6 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_exposure_control_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_exposure_control_operations.py index 22dbf5537371..0cbdae9591f9 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_exposure_control_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_exposure_control_operations.py @@ -132,11 +132,11 @@ async def get_feature_value( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ExposureControlResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ExposureControlResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -158,9 +158,9 @@ async def get_feature_value( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -177,7 +177,9 @@ async def get_feature_value( return deserialized - get_feature_value.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/getFeatureValue"} # type: ignore + get_feature_value.metadata = { + "url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/getFeatureValue" + } @overload async def get_feature_value_by_factory( @@ -269,11 +271,11 @@ async def get_feature_value_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ExposureControlResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ExposureControlResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -296,9 +298,9 @@ async def get_feature_value_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -315,7 +317,9 @@ async def get_feature_value_by_factory( return deserialized - get_feature_value_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getFeatureValue"} # type: ignore + get_feature_value_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getFeatureValue" + } @overload async def query_feature_values_by_factory( @@ -411,11 +415,11 @@ async def query_feature_values_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ExposureControlBatchResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ExposureControlBatchResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -438,9 +442,9 @@ async def query_feature_values_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -457,4 +461,6 @@ async def query_feature_values_by_factory( return deserialized - query_feature_values_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryFeaturesValue"} # type: ignore + query_feature_values_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryFeaturesValue" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_factories_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_factories_operations.py index af9718517eaa..c73ca80379d3 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_factories_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_factories_operations.py @@ -80,10 +80,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Factory"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.FactoryListResponse] + ) + cls: ClsType[_models.FactoryListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -104,7 +104,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -120,7 +120,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -128,13 +128,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("FactoryListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -147,7 +147,7 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/factories"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/factories"} @overload async def configure_factory_repo( @@ -222,11 +222,11 @@ async def configure_factory_repo( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Factory] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Factory] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -248,9 +248,9 @@ async def configure_factory_repo( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -267,7 +267,9 @@ async def configure_factory_repo( return deserialized - configure_factory_repo.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/configureFactoryRepo"} # type: ignore + configure_factory_repo.metadata = { + "url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/configureFactoryRepo" + } @distributed_trace def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> AsyncIterable["_models.Factory"]: @@ -283,10 +285,10 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Asy _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.FactoryListResponse] + ) + cls: ClsType[_models.FactoryListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -308,7 +310,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -324,7 +326,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -332,13 +334,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("FactoryListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -351,7 +353,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories"} # type: ignore + list_by_resource_group.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories" + } @overload async def create_or_update( @@ -454,11 +458,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Factory] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Factory] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -482,9 +486,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -501,7 +505,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}" + } @overload async def update( @@ -593,11 +599,11 @@ async def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Factory] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Factory] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -620,9 +626,9 @@ async def update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -639,7 +645,9 @@ async def update( return deserialized - update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}"} # type: ignore + update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}" + } @distributed_trace_async async def get( @@ -671,10 +679,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.Factory]] + ) + cls: ClsType[Optional[_models.Factory]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -687,9 +695,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -708,7 +716,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -736,10 +746,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -751,9 +761,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -766,7 +776,9 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}" + } @overload async def get_git_hub_access_token( @@ -859,11 +871,11 @@ async def get_git_hub_access_token( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.GitHubAccessTokenResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.GitHubAccessTokenResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -886,9 +898,9 @@ async def get_git_hub_access_token( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -905,7 +917,9 @@ async def get_git_hub_access_token( return deserialized - get_git_hub_access_token.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getGitHubAccessToken"} # type: ignore + get_git_hub_access_token.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getGitHubAccessToken" + } @overload async def get_data_plane_access( @@ -993,11 +1007,11 @@ async def get_data_plane_access( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.AccessPolicyResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.AccessPolicyResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -1020,9 +1034,9 @@ async def get_data_plane_access( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1039,4 +1053,6 @@ async def get_data_plane_access( return deserialized - get_data_plane_access.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getDataPlaneAccess"} # type: ignore + get_data_plane_access.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getDataPlaneAccess" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_global_parameters_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_global_parameters_operations.py index 1ae132b60496..e0f57d589b8a 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_global_parameters_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_global_parameters_operations.py @@ -83,10 +83,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.GlobalParameterListResponse] + ) + cls: ClsType[_models.GlobalParameterListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -109,7 +109,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -125,7 +125,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -133,13 +133,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("GlobalParameterListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -152,7 +152,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters" + } @distributed_trace_async async def get( @@ -182,10 +184,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.GlobalParameterResource] + ) + cls: ClsType[_models.GlobalParameterResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -198,9 +200,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -217,7 +219,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}" + } @overload async def create_or_update( @@ -318,11 +322,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.GlobalParameterResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.GlobalParameterResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -346,9 +350,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -365,7 +369,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -395,10 +401,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -411,9 +417,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -426,4 +432,6 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtime_nodes_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtime_nodes_operations.py index faf341b1528b..13c3d4712b0c 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtime_nodes_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtime_nodes_operations.py @@ -90,10 +90,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SelfHostedIntegrationRuntimeNode] + ) + cls: ClsType[_models.SelfHostedIntegrationRuntimeNode] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -107,9 +107,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -126,7 +126,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -158,10 +160,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -175,9 +177,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -190,7 +192,9 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}" + } @overload async def update( @@ -304,11 +308,11 @@ async def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SelfHostedIntegrationRuntimeNode] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SelfHostedIntegrationRuntimeNode] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -333,9 +337,9 @@ async def update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -352,7 +356,9 @@ async def update( return deserialized - update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}"} # type: ignore + update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}" + } @distributed_trace_async async def get_ip_address( @@ -384,10 +390,10 @@ async def get_ip_address( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeNodeIpAddress] + ) + cls: ClsType[_models.IntegrationRuntimeNodeIpAddress] = kwargs.pop("cls", None) request = build_get_ip_address_request( resource_group_name=resource_group_name, @@ -401,9 +407,9 @@ async def get_ip_address( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -420,4 +426,6 @@ async def get_ip_address( return deserialized - get_ip_address.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}/ipAddress"} # type: ignore + get_ip_address.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}/ipAddress" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtime_object_metadata_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtime_object_metadata_operations.py index 0012e02fe0d3..c1fbd1f1810a 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtime_object_metadata_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtime_object_metadata_operations.py @@ -71,10 +71,10 @@ async def _refresh_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.SsisObjectMetadataStatusResponse]] + ) + cls: ClsType[Optional[_models.SsisObjectMetadataStatusResponse]] = kwargs.pop("cls", None) request = build_refresh_request( resource_group_name=resource_group_name, @@ -87,9 +87,9 @@ async def _refresh_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -108,7 +108,9 @@ async def _refresh_initial( return deserialized - _refresh_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/refreshObjectMetadata"} # type: ignore + _refresh_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/refreshObjectMetadata" + } @distributed_trace_async async def begin_refresh( @@ -139,15 +141,15 @@ async def begin_refresh( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SsisObjectMetadataStatusResponse] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + cls: ClsType[_models.SsisObjectMetadataStatusResponse] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = await self._refresh_initial( # type: ignore + raw_result = await self._refresh_initial( resource_group_name=resource_group_name, factory_name=factory_name, integration_runtime_name=integration_runtime_name, @@ -166,7 +168,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -178,9 +180,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_refresh.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/refreshObjectMetadata"} # type: ignore + begin_refresh.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/refreshObjectMetadata" + } @overload async def get( @@ -286,11 +290,11 @@ async def get( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SsisObjectMetadataListResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SsisObjectMetadataListResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -317,9 +321,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -336,4 +340,6 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getObjectMetadata"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getObjectMetadata" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtimes_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtimes_operations.py index 214c0d5fa99e..0eae2855948b 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtimes_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_integration_runtimes_operations.py @@ -98,10 +98,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeListResponse] + ) + cls: ClsType[_models.IntegrationRuntimeListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -124,7 +124,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -140,7 +140,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -148,13 +148,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("IntegrationRuntimeListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -167,7 +167,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes" + } @overload async def create_or_update( @@ -283,11 +285,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.IntegrationRuntimeResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -312,9 +314,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -331,7 +333,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}" + } @distributed_trace_async async def get( @@ -370,10 +374,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.IntegrationRuntimeResource]] + ) + cls: ClsType[Optional[_models.IntegrationRuntimeResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -387,9 +391,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -408,7 +412,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}" + } @overload async def update( @@ -513,11 +519,11 @@ async def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.IntegrationRuntimeResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -541,9 +547,9 @@ async def update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -560,7 +566,9 @@ async def update( return deserialized - update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}"} # type: ignore + update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -590,10 +598,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -606,9 +614,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -621,7 +629,9 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}" + } @distributed_trace_async async def get_status( @@ -651,10 +661,10 @@ async def get_status( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeStatusResponse] + ) + cls: ClsType[_models.IntegrationRuntimeStatusResponse] = kwargs.pop("cls", None) request = build_get_status_request( resource_group_name=resource_group_name, @@ -667,9 +677,9 @@ async def get_status( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -686,7 +696,9 @@ async def get_status( return deserialized - get_status.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getStatus"} # type: ignore + get_status.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getStatus" + } @distributed_trace_async async def list_outbound_network_dependencies_endpoints( @@ -718,12 +730,10 @@ async def list_outbound_network_dependencies_endpoints( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop( - "cls", None - ) # type: ClsType[_models.IntegrationRuntimeOutboundNetworkDependenciesEndpointsResponse] + ) + cls: ClsType[_models.IntegrationRuntimeOutboundNetworkDependenciesEndpointsResponse] = kwargs.pop("cls", None) request = build_list_outbound_network_dependencies_endpoints_request( resource_group_name=resource_group_name, @@ -736,9 +746,9 @@ async def list_outbound_network_dependencies_endpoints( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -757,7 +767,9 @@ async def list_outbound_network_dependencies_endpoints( return deserialized - list_outbound_network_dependencies_endpoints.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/outboundNetworkDependenciesEndpoints"} # type: ignore + list_outbound_network_dependencies_endpoints.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/outboundNetworkDependenciesEndpoints" + } @distributed_trace_async async def get_connection_info( @@ -788,10 +800,10 @@ async def get_connection_info( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeConnectionInfo] + ) + cls: ClsType[_models.IntegrationRuntimeConnectionInfo] = kwargs.pop("cls", None) request = build_get_connection_info_request( resource_group_name=resource_group_name, @@ -804,9 +816,9 @@ async def get_connection_info( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -823,7 +835,9 @@ async def get_connection_info( return deserialized - get_connection_info.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getConnectionInfo"} # type: ignore + get_connection_info.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getConnectionInfo" + } @overload async def regenerate_auth_key( @@ -928,11 +942,11 @@ async def regenerate_auth_key( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeAuthKeys] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.IntegrationRuntimeAuthKeys] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -956,9 +970,9 @@ async def regenerate_auth_key( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -975,7 +989,9 @@ async def regenerate_auth_key( return deserialized - regenerate_auth_key.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/regenerateAuthKey"} # type: ignore + regenerate_auth_key.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/regenerateAuthKey" + } @distributed_trace_async async def list_auth_keys( @@ -1005,10 +1021,10 @@ async def list_auth_keys( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeAuthKeys] + ) + cls: ClsType[_models.IntegrationRuntimeAuthKeys] = kwargs.pop("cls", None) request = build_list_auth_keys_request( resource_group_name=resource_group_name, @@ -1021,9 +1037,9 @@ async def list_auth_keys( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1040,7 +1056,9 @@ async def list_auth_keys( return deserialized - list_auth_keys.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/listAuthKeys"} # type: ignore + list_auth_keys.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/listAuthKeys" + } async def _start_initial( self, resource_group_name: str, factory_name: str, integration_runtime_name: str, **kwargs: Any @@ -1056,10 +1074,10 @@ async def _start_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.IntegrationRuntimeStatusResponse]] + ) + cls: ClsType[Optional[_models.IntegrationRuntimeStatusResponse]] = kwargs.pop("cls", None) request = build_start_request( resource_group_name=resource_group_name, @@ -1072,9 +1090,9 @@ async def _start_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1093,7 +1111,9 @@ async def _start_initial( return deserialized - _start_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/start"} # type: ignore + _start_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/start" + } @distributed_trace_async async def begin_start( @@ -1124,15 +1144,15 @@ async def begin_start( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeStatusResponse] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + cls: ClsType[_models.IntegrationRuntimeStatusResponse] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = await self._start_initial( # type: ignore + raw_result = await self._start_initial( resource_group_name=resource_group_name, factory_name=factory_name, integration_runtime_name=integration_runtime_name, @@ -1151,7 +1171,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -1163,9 +1183,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_start.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/start"} # type: ignore + begin_start.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/start" + } async def _stop_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, factory_name: str, integration_runtime_name: str, **kwargs: Any @@ -1181,10 +1203,10 @@ async def _stop_initial( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_stop_request( resource_group_name=resource_group_name, @@ -1197,9 +1219,9 @@ async def _stop_initial( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1212,7 +1234,9 @@ async def _stop_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _stop_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/stop"} # type: ignore + _stop_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/stop" + } @distributed_trace_async async def begin_stop( @@ -1241,13 +1265,13 @@ async def begin_stop( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: raw_result = await self._stop_initial( # type: ignore resource_group_name=resource_group_name, @@ -1266,7 +1290,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- return cls(pipeline_response, None, {}) if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -1278,9 +1302,11 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/stop"} # type: ignore + begin_stop.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/stop" + } @distributed_trace_async async def sync_credentials( # pylint: disable=inconsistent-return-statements @@ -1313,10 +1339,10 @@ async def sync_credentials( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_sync_credentials_request( resource_group_name=resource_group_name, @@ -1329,9 +1355,9 @@ async def sync_credentials( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1344,7 +1370,9 @@ async def sync_credentials( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - sync_credentials.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/syncCredentials"} # type: ignore + sync_credentials.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/syncCredentials" + } @distributed_trace_async async def get_monitoring_data( @@ -1375,10 +1403,10 @@ async def get_monitoring_data( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeMonitoringData] + ) + cls: ClsType[_models.IntegrationRuntimeMonitoringData] = kwargs.pop("cls", None) request = build_get_monitoring_data_request( resource_group_name=resource_group_name, @@ -1391,9 +1419,9 @@ async def get_monitoring_data( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1410,7 +1438,9 @@ async def get_monitoring_data( return deserialized - get_monitoring_data.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/monitoringData"} # type: ignore + get_monitoring_data.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/monitoringData" + } @distributed_trace_async async def upgrade( # pylint: disable=inconsistent-return-statements @@ -1440,10 +1470,10 @@ async def upgrade( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_upgrade_request( resource_group_name=resource_group_name, @@ -1456,9 +1486,9 @@ async def upgrade( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1471,7 +1501,9 @@ async def upgrade( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - upgrade.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/upgrade"} # type: ignore + upgrade.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/upgrade" + } @overload async def remove_links( # pylint: disable=inconsistent-return-statements @@ -1579,11 +1611,11 @@ async def remove_links( # pylint: disable=inconsistent-return-statements _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[None] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -1607,9 +1639,9 @@ async def remove_links( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1622,7 +1654,9 @@ async def remove_links( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - remove_links.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/removeLinks"} # type: ignore + remove_links.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/removeLinks" + } @overload async def create_linked_integration_runtime( @@ -1727,11 +1761,11 @@ async def create_linked_integration_runtime( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeStatusResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.IntegrationRuntimeStatusResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -1757,9 +1791,9 @@ async def create_linked_integration_runtime( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1776,4 +1810,6 @@ async def create_linked_integration_runtime( return deserialized - create_linked_integration_runtime.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/linkedIntegrationRuntime"} # type: ignore + create_linked_integration_runtime.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/linkedIntegrationRuntime" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_linked_services_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_linked_services_operations.py index 8a8054cae74d..6018af604b30 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_linked_services_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_linked_services_operations.py @@ -83,10 +83,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.LinkedServiceListResponse] + ) + cls: ClsType[_models.LinkedServiceListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -109,7 +109,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -125,7 +125,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -133,13 +133,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("LinkedServiceListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -152,7 +152,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices" + } @overload async def create_or_update( @@ -268,11 +270,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.LinkedServiceResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.LinkedServiceResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -297,9 +299,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -316,7 +318,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}" + } @distributed_trace_async async def get( @@ -355,10 +359,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.LinkedServiceResource]] + ) + cls: ClsType[Optional[_models.LinkedServiceResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -372,9 +376,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -393,7 +397,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -423,10 +429,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -439,9 +445,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -454,4 +460,6 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_managed_private_endpoints_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_managed_private_endpoints_operations.py index 2239718402b3..d1455ccb054c 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_managed_private_endpoints_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_managed_private_endpoints_operations.py @@ -85,10 +85,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedPrivateEndpointListResponse] + ) + cls: ClsType[_models.ManagedPrivateEndpointListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -112,7 +112,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -128,7 +128,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -136,13 +136,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("ManagedPrivateEndpointListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -155,7 +155,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints" + } @overload async def create_or_update( @@ -281,11 +283,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedPrivateEndpointResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ManagedPrivateEndpointResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -311,9 +313,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -330,7 +332,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}" + } @distributed_trace_async async def get( @@ -372,10 +376,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedPrivateEndpointResource] + ) + cls: ClsType[_models.ManagedPrivateEndpointResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -390,9 +394,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -409,7 +413,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -446,10 +452,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -463,9 +469,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -478,4 +484,6 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_managed_virtual_networks_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_managed_virtual_networks_operations.py index 663dc96f054b..276f022b6719 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_managed_virtual_networks_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_managed_virtual_networks_operations.py @@ -82,10 +82,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedVirtualNetworkListResponse] + ) + cls: ClsType[_models.ManagedVirtualNetworkListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -108,7 +108,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -124,7 +124,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -132,13 +132,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("ManagedVirtualNetworkListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -151,7 +151,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks" + } @overload async def create_or_update( @@ -268,11 +270,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedVirtualNetworkResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ManagedVirtualNetworkResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -297,9 +299,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -316,7 +318,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}" + } @distributed_trace_async async def get( @@ -355,10 +359,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedVirtualNetworkResource] + ) + cls: ClsType[_models.ManagedVirtualNetworkResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -372,9 +376,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -391,4 +395,6 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_operations.py index 87f421a23e8c..922f278d897a 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_operations.py @@ -69,10 +69,10 @@ def list(self, **kwargs: Any) -> AsyncIterable["_models.Operation"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResponse] + ) + cls: ClsType[_models.OperationListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -92,7 +92,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -108,7 +108,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -116,13 +116,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("OperationListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -135,4 +135,4 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list.metadata = {"url": "/providers/Microsoft.DataFactory/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.DataFactory/operations"} diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_pipeline_runs_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_pipeline_runs_operations.py index b70960a236e5..dcd2402601df 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_pipeline_runs_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_pipeline_runs_operations.py @@ -149,11 +149,11 @@ async def query_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PipelineRunsQueryResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.PipelineRunsQueryResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -176,9 +176,9 @@ async def query_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -195,7 +195,9 @@ async def query_by_factory( return deserialized - query_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryPipelineRuns"} # type: ignore + query_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryPipelineRuns" + } @distributed_trace_async async def get(self, resource_group_name: str, factory_name: str, run_id: str, **kwargs: Any) -> _models.PipelineRun: @@ -223,10 +225,10 @@ async def get(self, resource_group_name: str, factory_name: str, run_id: str, ** _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PipelineRun] + ) + cls: ClsType[_models.PipelineRun] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -239,9 +241,9 @@ async def get(self, resource_group_name: str, factory_name: str, run_id: str, ** params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -258,7 +260,9 @@ async def get(self, resource_group_name: str, factory_name: str, run_id: str, ** return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}" + } @distributed_trace_async async def cancel( # pylint: disable=inconsistent-return-statements @@ -296,10 +300,10 @@ async def cancel( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_cancel_request( resource_group_name=resource_group_name, @@ -313,9 +317,9 @@ async def cancel( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -328,4 +332,6 @@ async def cancel( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - cancel.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}/cancel"} # type: ignore + cancel.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}/cancel" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_pipelines_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_pipelines_operations.py index 362ba538aacc..0b454f2ba9bc 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_pipelines_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_pipelines_operations.py @@ -88,10 +88,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PipelineListResponse] + ) + cls: ClsType[_models.PipelineListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -114,7 +114,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -130,7 +130,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -138,13 +138,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("PipelineListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -157,7 +157,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines" + } @overload async def create_or_update( @@ -269,11 +271,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PipelineResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.PipelineResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -298,9 +300,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -317,7 +319,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}" + } @distributed_trace_async async def get( @@ -356,10 +360,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PipelineResource]] + ) + cls: ClsType[Optional[_models.PipelineResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -373,9 +377,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -394,7 +398,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -424,10 +430,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -440,9 +446,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -455,7 +461,9 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}" + } @overload async def create_run( @@ -612,11 +620,11 @@ async def create_run( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.CreateRunResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.CreateRunResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -647,9 +655,9 @@ async def create_run( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -666,4 +674,6 @@ async def create_run( return deserialized - create_run.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}/createRun"} # type: ignore + create_run.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}/createRun" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_end_point_connections_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_end_point_connections_operations.py index 45b152fb10f9..da2bcba32bdc 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_end_point_connections_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_end_point_connections_operations.py @@ -77,10 +77,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResponse] + ) + cls: ClsType[_models.PrivateEndpointConnectionListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -103,7 +103,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -119,7 +119,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -127,13 +127,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("PrivateEndpointConnectionListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -146,4 +146,6 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndPointConnections"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndPointConnections" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_endpoint_connection_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_endpoint_connection_operations.py index cc3436dd9d76..7752e9529b39 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_endpoint_connection_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_endpoint_connection_operations.py @@ -174,11 +174,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.PrivateEndpointConnectionResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -203,9 +203,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -222,7 +222,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}" + } @distributed_trace_async async def get( @@ -261,10 +263,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionResource] + ) + cls: ClsType[_models.PrivateEndpointConnectionResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -278,9 +280,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -297,7 +299,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -327,10 +331,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -343,9 +347,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -358,4 +362,6 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_link_resources_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_link_resources_operations.py index f1f97b313640..11aeb413aba4 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_link_resources_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_private_link_resources_operations.py @@ -81,10 +81,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourcesWrapper] + ) + cls: ClsType[_models.PrivateLinkResourcesWrapper] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -96,9 +96,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -115,4 +115,6 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateLinkResources"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateLinkResources" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_trigger_runs_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_trigger_runs_operations.py index 7b9e8a579397..d4451f0ad1b6 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_trigger_runs_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_trigger_runs_operations.py @@ -89,10 +89,10 @@ async def rerun( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_rerun_request( resource_group_name=resource_group_name, @@ -106,9 +106,9 @@ async def rerun( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -121,7 +121,9 @@ async def rerun( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - rerun.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/triggerRuns/{runId}/rerun"} # type: ignore + rerun.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/triggerRuns/{runId}/rerun" + } @distributed_trace_async async def cancel( # pylint: disable=inconsistent-return-statements @@ -153,10 +155,10 @@ async def cancel( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_cancel_request( resource_group_name=resource_group_name, @@ -170,9 +172,9 @@ async def cancel( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -185,7 +187,9 @@ async def cancel( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - cancel.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/triggerRuns/{runId}/cancel"} # type: ignore + cancel.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/triggerRuns/{runId}/cancel" + } @overload async def query_by_factory( @@ -277,11 +281,11 @@ async def query_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerRunsQueryResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.TriggerRunsQueryResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -304,9 +308,9 @@ async def query_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -323,4 +327,6 @@ async def query_by_factory( return deserialized - query_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryTriggerRuns"} # type: ignore + query_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryTriggerRuns" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_triggers_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_triggers_operations.py index aca7bc1db8f6..31c4f600fd18 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_triggers_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/aio/operations/_triggers_operations.py @@ -89,10 +89,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerListResponse] + ) + cls: ClsType[_models.TriggerListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -115,7 +115,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -131,7 +131,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -139,13 +139,13 @@ async def extract_data(pipeline_response): deserialized = self._deserialize("TriggerListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -158,7 +158,9 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers" + } @overload async def query_by_factory( @@ -250,11 +252,11 @@ async def query_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerQueryResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.TriggerQueryResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -277,9 +279,9 @@ async def query_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -296,7 +298,9 @@ async def query_by_factory( return deserialized - query_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/querytriggers"} # type: ignore + query_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/querytriggers" + } @overload async def create_or_update( @@ -408,11 +412,11 @@ async def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.TriggerResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -437,9 +441,9 @@ async def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -456,7 +460,9 @@ async def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}" + } @distributed_trace_async async def get( @@ -495,10 +501,10 @@ async def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.TriggerResource]] + ) + cls: ClsType[Optional[_models.TriggerResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -512,9 +518,9 @@ async def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -533,7 +539,9 @@ async def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}" + } @distributed_trace_async async def delete( # pylint: disable=inconsistent-return-statements @@ -563,10 +571,10 @@ async def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -579,9 +587,9 @@ async def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -594,7 +602,9 @@ async def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}" + } async def _subscribe_to_events_initial( self, resource_group_name: str, factory_name: str, trigger_name: str, **kwargs: Any @@ -610,10 +620,10 @@ async def _subscribe_to_events_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.TriggerSubscriptionOperationStatus]] + ) + cls: ClsType[Optional[_models.TriggerSubscriptionOperationStatus]] = kwargs.pop("cls", None) request = build_subscribe_to_events_request( resource_group_name=resource_group_name, @@ -626,9 +636,9 @@ async def _subscribe_to_events_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -647,7 +657,9 @@ async def _subscribe_to_events_initial( return deserialized - _subscribe_to_events_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/subscribeToEvents"} # type: ignore + _subscribe_to_events_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/subscribeToEvents" + } @distributed_trace_async async def begin_subscribe_to_events( @@ -678,15 +690,15 @@ async def begin_subscribe_to_events( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerSubscriptionOperationStatus] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + cls: ClsType[_models.TriggerSubscriptionOperationStatus] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = await self._subscribe_to_events_initial( # type: ignore + raw_result = await self._subscribe_to_events_initial( resource_group_name=resource_group_name, factory_name=factory_name, trigger_name=trigger_name, @@ -705,7 +717,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -717,9 +729,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_subscribe_to_events.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/subscribeToEvents"} # type: ignore + begin_subscribe_to_events.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/subscribeToEvents" + } @distributed_trace_async async def get_event_subscription_status( @@ -749,10 +763,10 @@ async def get_event_subscription_status( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerSubscriptionOperationStatus] + ) + cls: ClsType[_models.TriggerSubscriptionOperationStatus] = kwargs.pop("cls", None) request = build_get_event_subscription_status_request( resource_group_name=resource_group_name, @@ -765,9 +779,9 @@ async def get_event_subscription_status( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -784,7 +798,9 @@ async def get_event_subscription_status( return deserialized - get_event_subscription_status.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/getEventSubscriptionStatus"} # type: ignore + get_event_subscription_status.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/getEventSubscriptionStatus" + } async def _unsubscribe_from_events_initial( self, resource_group_name: str, factory_name: str, trigger_name: str, **kwargs: Any @@ -800,10 +816,10 @@ async def _unsubscribe_from_events_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.TriggerSubscriptionOperationStatus]] + ) + cls: ClsType[Optional[_models.TriggerSubscriptionOperationStatus]] = kwargs.pop("cls", None) request = build_unsubscribe_from_events_request( resource_group_name=resource_group_name, @@ -816,9 +832,9 @@ async def _unsubscribe_from_events_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -837,7 +853,9 @@ async def _unsubscribe_from_events_initial( return deserialized - _unsubscribe_from_events_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/unsubscribeFromEvents"} # type: ignore + _unsubscribe_from_events_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/unsubscribeFromEvents" + } @distributed_trace_async async def begin_unsubscribe_from_events( @@ -868,15 +886,15 @@ async def begin_unsubscribe_from_events( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerSubscriptionOperationStatus] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + cls: ClsType[_models.TriggerSubscriptionOperationStatus] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = await self._unsubscribe_from_events_initial( # type: ignore + raw_result = await self._unsubscribe_from_events_initial( resource_group_name=resource_group_name, factory_name=factory_name, trigger_name=trigger_name, @@ -895,7 +913,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -907,9 +925,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_unsubscribe_from_events.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/unsubscribeFromEvents"} # type: ignore + begin_unsubscribe_from_events.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/unsubscribeFromEvents" + } async def _start_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, factory_name: str, trigger_name: str, **kwargs: Any @@ -925,10 +945,10 @@ async def _start_initial( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_start_request( resource_group_name=resource_group_name, @@ -941,9 +961,9 @@ async def _start_initial( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -956,7 +976,9 @@ async def _start_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _start_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/start"} # type: ignore + _start_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/start" + } @distributed_trace_async async def begin_start( @@ -985,13 +1007,13 @@ async def begin_start( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: raw_result = await self._start_initial( # type: ignore resource_group_name=resource_group_name, @@ -1010,7 +1032,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- return cls(pipeline_response, None, {}) if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -1022,9 +1044,11 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_start.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/start"} # type: ignore + begin_start.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/start" + } async def _stop_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, factory_name: str, trigger_name: str, **kwargs: Any @@ -1040,10 +1064,10 @@ async def _stop_initial( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_stop_request( resource_group_name=resource_group_name, @@ -1056,9 +1080,9 @@ async def _stop_initial( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1071,7 +1095,9 @@ async def _stop_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _stop_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/stop"} # type: ignore + _stop_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/stop" + } @distributed_trace_async async def begin_stop( @@ -1100,13 +1126,13 @@ async def begin_stop( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] - polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + ) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: raw_result = await self._stop_initial( # type: ignore resource_group_name=resource_group_name, @@ -1125,7 +1151,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- return cls(pipeline_response, None, {}) if polling is True: - polling_method = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) # type: AsyncPollingMethod + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) else: @@ -1137,6 +1163,8 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- client=self._client, deserialization_callback=get_long_running_output, ) - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/stop"} # type: ignore + begin_stop.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/stop" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/models/__init__.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/models/__init__.py index 9aaa410fc93a..4676741bb7a7 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/models/__init__.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/models/__init__.py @@ -168,6 +168,7 @@ from ._models_py3 import CreateLinkedIntegrationRuntimeRequest from ._models_py3 import CreateRunResponse from ._models_py3 import Credential +from ._models_py3 import CredentialListResponse from ._models_py3 import CredentialReference from ._models_py3 import CredentialResource from ._models_py3 import CustomActivity @@ -395,6 +396,7 @@ from ._models_py3 import MagentoObjectDataset from ._models_py3 import MagentoSource from ._models_py3 import ManagedIdentityCredential +from ._models_py3 import ManagedIdentityCredentialResource from ._models_py3 import ManagedIntegrationRuntime from ._models_py3 import ManagedIntegrationRuntimeError from ._models_py3 import ManagedIntegrationRuntimeNode @@ -500,6 +502,7 @@ from ._models_py3 import PostgreSqlLinkedService from ._models_py3 import PostgreSqlSource from ._models_py3 import PostgreSqlTableDataset +from ._models_py3 import PowerBILinkedService from ._models_py3 import PowerQuerySink from ._models_py3 import PowerQuerySinkMapping from ._models_py3 import PowerQuerySource @@ -840,7 +843,7 @@ from ._data_factory_management_client_enums import WebHookActivityMethod from ._data_factory_management_client_enums import ZendeskAuthenticationType from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import * # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -1006,6 +1009,7 @@ "CreateLinkedIntegrationRuntimeRequest", "CreateRunResponse", "Credential", + "CredentialListResponse", "CredentialReference", "CredentialResource", "CustomActivity", @@ -1233,6 +1237,7 @@ "MagentoObjectDataset", "MagentoSource", "ManagedIdentityCredential", + "ManagedIdentityCredentialResource", "ManagedIntegrationRuntime", "ManagedIntegrationRuntimeError", "ManagedIntegrationRuntimeNode", @@ -1338,6 +1343,7 @@ "PostgreSqlLinkedService", "PostgreSqlSource", "PostgreSqlTableDataset", + "PowerBILinkedService", "PowerQuerySink", "PowerQuerySinkMapping", "PowerQuerySource", diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/models/_models_py3.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/models/_models_py3.py index 862cf8f30f3f..445ee8b5f8d1 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/models/_models_py3.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/models/_models_py3.py @@ -134,7 +134,7 @@ def __init__( super().__init__(**kwargs) self.additional_properties = additional_properties self.name = name - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.description = description self.depends_on = depends_on self.user_properties = user_properties @@ -467,8 +467,8 @@ class LinkedService(_serialization.Model): MongoDbLinkedService, MongoDbAtlasLinkedService, MongoDbV2LinkedService, MySqlLinkedService, NetezzaLinkedService, ODataLinkedService, OdbcLinkedService, Office365LinkedService, OracleLinkedService, OracleCloudStorageLinkedService, OracleServiceCloudLinkedService, - PaypalLinkedService, PhoenixLinkedService, PostgreSqlLinkedService, PrestoLinkedService, - QuickBooksLinkedService, QuickbaseLinkedService, ResponsysLinkedService, + PaypalLinkedService, PhoenixLinkedService, PostgreSqlLinkedService, PowerBILinkedService, + PrestoLinkedService, QuickBooksLinkedService, QuickbaseLinkedService, ResponsysLinkedService, RestServiceLinkedService, SalesforceLinkedService, SalesforceMarketingCloudLinkedService, SalesforceServiceCloudLinkedService, SapBWLinkedService, SapCloudForCustomerLinkedService, SapEccLinkedService, SapHanaLinkedService, SapOdpLinkedService, SapOpenHubLinkedService, @@ -591,6 +591,7 @@ class LinkedService(_serialization.Model): "Paypal": "PaypalLinkedService", "Phoenix": "PhoenixLinkedService", "PostgreSql": "PostgreSqlLinkedService", + "PowerBI": "PowerBILinkedService", "Presto": "PrestoLinkedService", "QuickBooks": "QuickBooksLinkedService", "Quickbase": "QuickbaseLinkedService", @@ -652,7 +653,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.connect_via = connect_via self.description = description self.parameters = parameters @@ -804,7 +805,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AmazonMWS" # type: str + self.type: str = "AmazonMWS" self.endpoint = endpoint self.marketplace_id = marketplace_id self.seller_id = seller_id @@ -1029,7 +1030,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.description = description self.structure = structure self.schema = schema @@ -1137,7 +1138,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AmazonMWSObject" # type: str + self.type: str = "AmazonMWSObject" self.table_name = table_name @@ -1259,7 +1260,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.source_retry_count = source_retry_count self.source_retry_wait = source_retry_wait self.max_concurrent_connections = max_concurrent_connections @@ -1431,7 +1432,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "TabularSource" # type: str + self.type: str = "TabularSource" self.query_timeout = query_timeout self.additional_columns = additional_columns @@ -1534,7 +1535,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "AmazonMWSSource" # type: str + self.type: str = "AmazonMWSSource" self.query = query @@ -1627,7 +1628,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AmazonRdsForOracle" # type: str + self.type: str = "AmazonRdsForOracle" self.connection_string = connection_string self.password = password self.encrypted_credential = encrypted_credential @@ -1802,7 +1803,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AmazonRdsForOracleSource" # type: str + self.type: str = "AmazonRdsForOracleSource" self.oracle_reader_query = oracle_reader_query self.query_timeout = query_timeout self.partition_option = partition_option @@ -1918,7 +1919,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AmazonRdsForOracleTable" # type: str + self.type: str = "AmazonRdsForOracleTable" self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -2030,7 +2031,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AmazonRdsForSqlServer" # type: str + self.type: str = "AmazonRdsForSqlServer" self.connection_string = connection_string self.user_name = user_name self.password = password @@ -2173,7 +2174,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "AmazonRdsForSqlServerSource" # type: str + self.type: str = "AmazonRdsForSqlServerSource" self.sql_reader_query = sql_reader_query self.sql_reader_stored_procedure_name = sql_reader_stored_procedure_name self.stored_procedure_parameters = stored_procedure_parameters @@ -2290,7 +2291,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AmazonRdsForSqlServerTable" # type: str + self.type: str = "AmazonRdsForSqlServerTable" self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -2409,7 +2410,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AmazonRedshift" # type: str + self.type: str = "AmazonRedshift" self.server = server self.username = username self.password = password @@ -2524,7 +2525,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "AmazonRedshiftSource" # type: str + self.type: str = "AmazonRedshiftSource" self.query = query self.redshift_unload_settings = redshift_unload_settings @@ -2645,7 +2646,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AmazonRedshiftTable" # type: str + self.type: str = "AmazonRedshiftTable" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -2761,7 +2762,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AmazonS3Compatible" # type: str + self.type: str = "AmazonS3Compatible" self.access_key_id = access_key_id self.secret_access_key = secret_access_key self.service_url = service_url @@ -2843,7 +2844,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.folder_path = folder_path self.file_name = file_name @@ -2915,7 +2916,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "AmazonS3CompatibleLocation" # type: str + self.type: str = "AmazonS3CompatibleLocation" self.bucket_name = bucket_name self.version = version @@ -2994,7 +2995,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.max_concurrent_connections = max_concurrent_connections self.disable_metrics_collection = disable_metrics_collection @@ -3133,7 +3134,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AmazonS3CompatibleReadSettings" # type: str + self.type: str = "AmazonS3CompatibleReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -3299,7 +3300,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AmazonS3Object" # type: str + self.type: str = "AmazonS3Object" self.bucket_name = bucket_name self.key = key self.prefix = prefix @@ -3424,7 +3425,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AmazonS3" # type: str + self.type: str = "AmazonS3" self.authentication_type = authentication_type self.access_key_id = access_key_id self.secret_access_key = secret_access_key @@ -3500,7 +3501,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "AmazonS3Location" # type: str + self.type: str = "AmazonS3Location" self.bucket_name = bucket_name self.version = version @@ -3639,7 +3640,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AmazonS3ReadSettings" # type: str + self.type: str = "AmazonS3ReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -3739,7 +3740,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "Container" # type: str + self.type: str = "Container" class AppendVariableActivity(ControlActivity): @@ -3819,7 +3820,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "AppendVariable" # type: str + self.type: str = "AppendVariable" self.variable_name = variable_name self.value = value @@ -3909,7 +3910,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AppFigures" # type: str + self.type: str = "AppFigures" self.user_name = user_name self.password = password self.client_key = client_key @@ -4019,7 +4020,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Asana" # type: str + self.type: str = "Asana" self.api_token = api_token self.encrypted_credential = encrypted_credential @@ -4137,7 +4138,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Avro" # type: str + self.type: str = "Avro" self.location = location self.avro_compression_codec = avro_compression_codec self.avro_compression_level = avro_compression_level @@ -4202,7 +4203,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.serializer = serializer self.deserializer = deserializer @@ -4254,7 +4255,7 @@ def __init__( super().__init__( additional_properties=additional_properties, serializer=serializer, deserializer=deserializer, **kwargs ) - self.type = "AvroFormat" # type: str + self.type: str = "AvroFormat" class CopySink(_serialization.Model): @@ -4393,7 +4394,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.write_batch_size = write_batch_size self.write_batch_timeout = write_batch_timeout self.sink_retry_count = sink_retry_count @@ -4504,7 +4505,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AvroSink" # type: str + self.type: str = "AvroSink" self.store_settings = store_settings self.format_settings = format_settings @@ -4595,7 +4596,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AvroSource" # type: str + self.type: str = "AvroSource" self.store_settings = store_settings self.additional_columns = additional_columns @@ -4643,7 +4644,7 @@ def __init__(self, *, additional_properties: Optional[Dict[str, JSON]] = None, * """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None class AvroWriteSettings(FormatWriteSettings): @@ -4709,7 +4710,7 @@ def __init__( :paramtype file_name_prefix: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "AvroWriteSettings" # type: str + self.type: str = "AvroWriteSettings" self.record_name = record_name self.record_namespace = record_namespace self.max_rows_per_file = max_rows_per_file @@ -4748,7 +4749,7 @@ class CustomSetupBase(_serialization.Model): def __init__(self, **kwargs): """ """ super().__init__(**kwargs) - self.type = None # type: Optional[str] + self.type: Optional[str] = None class AzPowerShellSetup(CustomSetupBase): @@ -4778,7 +4779,7 @@ def __init__(self, *, version: str, **kwargs): :paramtype version: str """ super().__init__(**kwargs) - self.type = "AzPowerShellSetup" # type: str + self.type: str = "AzPowerShellSetup" self.version = version @@ -4902,7 +4903,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureBatch" # type: str + self.type: str = "AzureBatch" self.account_name = account_name self.access_key = access_key self.batch_uri = batch_uri @@ -5056,7 +5057,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureBlob" # type: str + self.type: str = "AzureBlob" self.folder_path = folder_path self.table_root_location = table_root_location self.file_name = file_name @@ -5186,7 +5187,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureBlobFSFile" # type: str + self.type: str = "AzureBlobFSFile" self.folder_path = folder_path self.file_name = file_name self.format = format @@ -5348,7 +5349,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureBlobFS" # type: str + self.type: str = "AzureBlobFS" self.url = url self.account_key = account_key self.service_principal_id = service_principal_id @@ -5420,7 +5421,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "AzureBlobFSLocation" # type: str + self.type: str = "AzureBlobFSLocation" self.file_system = file_system @@ -5550,7 +5551,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureBlobFSReadSettings" # type: str + self.type: str = "AzureBlobFSReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -5666,7 +5667,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureBlobFSSink" # type: str + self.type: str = "AzureBlobFSSink" self.copy_behavior = copy_behavior self.metadata = metadata @@ -5767,7 +5768,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureBlobFSSource" # type: str + self.type: str = "AzureBlobFSSource" self.treat_empty_as_null = treat_empty_as_null self.skip_header_line_count = skip_header_line_count self.recursive = recursive @@ -5844,7 +5845,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.max_concurrent_connections = max_concurrent_connections self.disable_metrics_collection = disable_metrics_collection self.copy_behavior = copy_behavior @@ -5919,7 +5920,7 @@ def __init__( copy_behavior=copy_behavior, **kwargs ) - self.type = "AzureBlobFSWriteSettings" # type: str + self.type: str = "AzureBlobFSWriteSettings" self.block_size_in_mb = block_size_in_mb @@ -6085,7 +6086,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureBlobStorage" # type: str + self.type: str = "AzureBlobStorage" self.connection_string = connection_string self.account_key = account_key self.sas_uri = sas_uri @@ -6159,7 +6160,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "AzureBlobStorageLocation" # type: str + self.type: str = "AzureBlobStorageLocation" self.container = container @@ -6297,7 +6298,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureBlobStorageReadSettings" # type: str + self.type: str = "AzureBlobStorageReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -6379,7 +6380,7 @@ def __init__( copy_behavior=copy_behavior, **kwargs ) - self.type = "AzureBlobStorageWriteSettings" # type: str + self.type: str = "AzureBlobStorageWriteSettings" self.block_size_in_mb = block_size_in_mb @@ -6489,7 +6490,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureDatabricksDeltaLakeDataset" # type: str + self.type: str = "AzureDatabricksDeltaLakeDataset" self.table = table self.database = database @@ -6533,7 +6534,7 @@ def __init__(self, *, additional_properties: Optional[Dict[str, JSON]] = None, * """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None class AzureDatabricksDeltaLakeExportCommand(ExportSettings): @@ -6585,7 +6586,7 @@ def __init__( :paramtype timestamp_format: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "AzureDatabricksDeltaLakeExportCommand" # type: str + self.type: str = "AzureDatabricksDeltaLakeExportCommand" self.date_format = date_format self.timestamp_format = timestamp_format @@ -6629,7 +6630,7 @@ def __init__(self, *, additional_properties: Optional[Dict[str, JSON]] = None, * """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None class AzureDatabricksDeltaLakeImportCommand(ImportSettings): @@ -6681,7 +6682,7 @@ def __init__( :paramtype timestamp_format: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "AzureDatabricksDeltaLakeImportCommand" # type: str + self.type: str = "AzureDatabricksDeltaLakeImportCommand" self.date_format = date_format self.timestamp_format = timestamp_format @@ -6801,7 +6802,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureDatabricksDeltaLake" # type: str + self.type: str = "AzureDatabricksDeltaLake" self.domain = domain self.access_token = access_token self.cluster_id = cluster_id @@ -6915,7 +6916,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureDatabricksDeltaLakeSink" # type: str + self.type: str = "AzureDatabricksDeltaLakeSink" self.pre_copy_script = pre_copy_script self.import_settings = import_settings @@ -7007,7 +7008,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureDatabricksDeltaLakeSource" # type: str + self.type: str = "AzureDatabricksDeltaLakeSource" self.query = query self.export_settings = export_settings @@ -7249,7 +7250,7 @@ def __init__( # pylint: disable=too-many-locals annotations=annotations, **kwargs ) - self.type = "AzureDatabricks" # type: str + self.type: str = "AzureDatabricks" self.domain = domain self.access_token = access_token self.authentication = authentication @@ -7389,7 +7390,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "Execution" # type: str + self.type: str = "Execution" self.linked_service_name = linked_service_name self.policy = policy @@ -7490,7 +7491,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "AzureDataExplorerCommand" # type: str + self.type: str = "AzureDataExplorerCommand" self.command = command self.command_timeout = command_timeout @@ -7609,7 +7610,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureDataExplorer" # type: str + self.type: str = "AzureDataExplorer" self.endpoint = endpoint self.service_principal_id = service_principal_id self.service_principal_key = service_principal_key @@ -7732,7 +7733,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureDataExplorerSink" # type: str + self.type: str = "AzureDataExplorerSink" self.ingestion_mapping_name = ingestion_mapping_name self.ingestion_mapping_as_json = ingestion_mapping_as_json self.flush_immediately = flush_immediately @@ -7843,7 +7844,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureDataExplorerSource" # type: str + self.type: str = "AzureDataExplorerSource" self.query = query self.no_truncation = no_truncation self.query_timeout = query_timeout @@ -7950,7 +7951,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureDataExplorerTable" # type: str + self.type: str = "AzureDataExplorerTable" self.table = table @@ -8086,7 +8087,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureDataLakeAnalytics" # type: str + self.type: str = "AzureDataLakeAnalytics" self.account_name = account_name self.service_principal_id = service_principal_id self.service_principal_key = service_principal_key @@ -8219,7 +8220,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureDataLakeStoreFile" # type: str + self.type: str = "AzureDataLakeStoreFile" self.folder_path = folder_path self.file_name = file_name self.format = format @@ -8373,7 +8374,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureDataLakeStore" # type: str + self.type: str = "AzureDataLakeStore" self.data_lake_store_uri = data_lake_store_uri self.service_principal_id = service_principal_id self.service_principal_key = service_principal_key @@ -8437,7 +8438,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "AzureDataLakeStoreLocation" # type: str + self.type: str = "AzureDataLakeStoreLocation" class AzureDataLakeStoreReadSettings(StoreReadSettings): # pylint: disable=too-many-instance-attributes @@ -8586,7 +8587,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureDataLakeStoreReadSettings" # type: str + self.type: str = "AzureDataLakeStoreReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -8702,7 +8703,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureDataLakeStoreSink" # type: str + self.type: str = "AzureDataLakeStoreSink" self.copy_behavior = copy_behavior self.enable_adls_single_file_parallel = enable_adls_single_file_parallel @@ -8787,7 +8788,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureDataLakeStoreSource" # type: str + self.type: str = "AzureDataLakeStoreSource" self.recursive = recursive @@ -8862,7 +8863,7 @@ def __init__( copy_behavior=copy_behavior, **kwargs ) - self.type = "AzureDataLakeStoreWriteSettings" # type: str + self.type: str = "AzureDataLakeStoreWriteSettings" self.expiry_date_time = expiry_date_time @@ -9004,7 +9005,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureFileStorage" # type: str + self.type: str = "AzureFileStorage" self.host = host self.user_id = user_id self.password = password @@ -9068,7 +9069,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "AzureFileStorageLocation" # type: str + self.type: str = "AzureFileStorageLocation" class AzureFileStorageReadSettings(StoreReadSettings): # pylint: disable=too-many-instance-attributes @@ -9205,7 +9206,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureFileStorageReadSettings" # type: str + self.type: str = "AzureFileStorageReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -9279,7 +9280,7 @@ def __init__( copy_behavior=copy_behavior, **kwargs ) - self.type = "AzureFileStorageWriteSettings" # type: str + self.type: str = "AzureFileStorageWriteSettings" class AzureFunctionActivity(ExecutionActivity): # pylint: disable=too-many-instance-attributes @@ -9397,7 +9398,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "AzureFunctionActivity" # type: str + self.type: str = "AzureFunctionActivity" self.method = method self.function_name = function_name self.headers = headers @@ -9513,7 +9514,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureFunction" # type: str + self.type: str = "AzureFunction" self.function_app_url = function_app_url self.function_key = function_key self.encrypted_credential = encrypted_credential @@ -9601,7 +9602,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureKeyVault" # type: str + self.type: str = "AzureKeyVault" self.base_url = base_url self.credential = credential @@ -9631,7 +9632,7 @@ class SecretBase(_serialization.Model): def __init__(self, **kwargs): """ """ super().__init__(**kwargs) - self.type = None # type: Optional[str] + self.type: Optional[str] = None class AzureKeyVaultSecretReference(SecretBase): @@ -9683,7 +9684,7 @@ def __init__( :paramtype secret_version: JSON """ super().__init__(**kwargs) - self.type = "AzureKeyVaultSecret" # type: str + self.type: str = "AzureKeyVaultSecret" self.store = store self.secret_name = secret_name self.secret_version = secret_version @@ -9777,7 +9778,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureMariaDB" # type: str + self.type: str = "AzureMariaDB" self.connection_string = connection_string self.pwd = pwd self.encrypted_credential = encrypted_credential @@ -9881,7 +9882,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "AzureMariaDBSource" # type: str + self.type: str = "AzureMariaDBSource" self.query = query @@ -9983,7 +9984,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureMariaDBTable" # type: str + self.type: str = "AzureMariaDBTable" self.table_name = table_name @@ -10101,7 +10102,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "AzureMLBatchExecution" # type: str + self.type: str = "AzureMLBatchExecution" self.global_parameters = global_parameters self.web_service_outputs = web_service_outputs self.web_service_inputs = web_service_inputs @@ -10263,7 +10264,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "AzureMLExecutePipeline" # type: str + self.type: str = "AzureMLExecutePipeline" self.ml_pipeline_id = ml_pipeline_id self.ml_pipeline_endpoint_id = ml_pipeline_endpoint_id self.version = version @@ -10406,7 +10407,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureML" # type: str + self.type: str = "AzureML" self.ml_endpoint = ml_endpoint self.api_key = api_key self.update_resource_endpoint = update_resource_endpoint @@ -10544,7 +10545,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureMLService" # type: str + self.type: str = "AzureMLService" self.subscription_id = subscription_id self.resource_group_name = resource_group_name self.ml_workspace_name = ml_workspace_name @@ -10667,7 +10668,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "AzureMLUpdateResource" # type: str + self.type: str = "AzureMLUpdateResource" self.trained_model_name = trained_model_name self.trained_model_linked_service_name = trained_model_linked_service_name self.trained_model_file_path = trained_model_file_path @@ -10799,7 +10800,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureMySql" # type: str + self.type: str = "AzureMySql" self.connection_string = connection_string self.password = password self.encrypted_credential = encrypted_credential @@ -10903,7 +10904,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureMySqlSink" # type: str + self.type: str = "AzureMySqlSink" self.pre_copy_script = pre_copy_script @@ -11003,7 +11004,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "AzureMySqlSource" # type: str + self.type: str = "AzureMySqlSource" self.query = query @@ -11115,7 +11116,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureMySqlTable" # type: str + self.type: str = "AzureMySqlTable" self.table_name = table_name self.table = table @@ -11208,7 +11209,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzurePostgreSql" # type: str + self.type: str = "AzurePostgreSql" self.connection_string = connection_string self.password = password self.encrypted_credential = encrypted_credential @@ -11312,7 +11313,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzurePostgreSqlSink" # type: str + self.type: str = "AzurePostgreSqlSink" self.pre_copy_script = pre_copy_script @@ -11414,7 +11415,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "AzurePostgreSqlSource" # type: str + self.type: str = "AzurePostgreSqlSource" self.query = query @@ -11534,7 +11535,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzurePostgreSqlTable" # type: str + self.type: str = "AzurePostgreSqlTable" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -11630,7 +11631,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureQueueSink" # type: str + self.type: str = "AzureQueueSink" class AzureSearchIndexDataset(Dataset): @@ -11734,7 +11735,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureSearchIndex" # type: str + self.type: str = "AzureSearchIndex" self.index_name = index_name @@ -11838,7 +11839,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureSearchIndexSink" # type: str + self.type: str = "AzureSearchIndexSink" self.write_behavior = write_behavior @@ -11931,7 +11932,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureSearch" # type: str + self.type: str = "AzureSearch" self.url = url self.key = key self.encrypted_credential = encrypted_credential @@ -12076,7 +12077,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureSqlDatabase" # type: str + self.type: str = "AzureSqlDatabase" self.connection_string = connection_string self.password = password self.service_principal_id = service_principal_id @@ -12219,7 +12220,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureSqlDW" # type: str + self.type: str = "AzureSqlDW" self.connection_string = connection_string self.password = password self.service_principal_id = service_principal_id @@ -12346,7 +12347,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureSqlDWTable" # type: str + self.type: str = "AzureSqlDWTable" self.table_name = table_name self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -12491,7 +12492,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureSqlMI" # type: str + self.type: str = "AzureSqlMI" self.connection_string = connection_string self.password = password self.service_principal_id = service_principal_id @@ -12619,7 +12620,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureSqlMITable" # type: str + self.type: str = "AzureSqlMITable" self.table_name = table_name self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -12786,7 +12787,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureSqlSink" # type: str + self.type: str = "AzureSqlSink" self.sql_writer_stored_procedure_name = sql_writer_stored_procedure_name self.sql_writer_table_type = sql_writer_table_type self.pre_copy_script = pre_copy_script @@ -12933,7 +12934,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "AzureSqlSource" # type: str + self.type: str = "AzureSqlSource" self.sql_reader_query = sql_reader_query self.sql_reader_stored_procedure_name = sql_reader_stored_procedure_name self.stored_procedure_parameters = stored_procedure_parameters @@ -13058,7 +13059,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureSqlTable" # type: str + self.type: str = "AzureSqlTable" self.table_name = table_name self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -13166,7 +13167,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureStorage" # type: str + self.type: str = "AzureStorage" self.connection_string = connection_string self.account_key = account_key self.sas_uri = sas_uri @@ -13265,7 +13266,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureSynapseArtifacts" # type: str + self.type: str = "AzureSynapseArtifacts" self.endpoint = endpoint self.authentication = authentication self.workspace_resource_id = workspace_resource_id @@ -13372,7 +13373,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "AzureTable" # type: str + self.type: str = "AzureTable" self.table_name = table_name @@ -13498,7 +13499,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "AzureTableSink" # type: str + self.type: str = "AzureTableSink" self.azure_table_default_partition_key_value = azure_table_default_partition_key_value self.azure_table_partition_key_name = azure_table_partition_key_name self.azure_table_row_key_name = azure_table_row_key_name @@ -13611,7 +13612,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "AzureTableSource" # type: str + self.type: str = "AzureTableSource" self.azure_table_source_query = azure_table_source_query self.azure_table_source_ignore_table_not_found = azure_table_source_ignore_table_not_found @@ -13718,7 +13719,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "AzureTableStorage" # type: str + self.type: str = "AzureTableStorage" self.connection_string = connection_string self.account_key = account_key self.sas_uri = sas_uri @@ -13865,7 +13866,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Binary" # type: str + self.type: str = "Binary" self.location = location self.compression = compression @@ -13911,7 +13912,7 @@ def __init__(self, *, additional_properties: Optional[Dict[str, JSON]] = None, * """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None class BinaryReadSettings(FormatReadSettings): @@ -13953,7 +13954,7 @@ def __init__( :paramtype compression_properties: ~azure.mgmt.datafactory.models.CompressionReadSettings """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "BinaryReadSettings" # type: str + self.type: str = "BinaryReadSettings" self.compression_properties = compression_properties @@ -14053,7 +14054,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "BinarySink" # type: str + self.type: str = "BinarySink" self.store_settings = store_settings @@ -14141,7 +14142,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "BinarySource" # type: str + self.type: str = "BinarySource" self.store_settings = store_settings self.format_settings = format_settings @@ -14211,7 +14212,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.description = description self.runtime_state = None self.annotations = annotations @@ -14289,7 +14290,7 @@ def __init__( super().__init__( additional_properties=additional_properties, description=description, annotations=annotations, **kwargs ) - self.type = "MultiplePipelineTrigger" # type: str + self.type: str = "MultiplePipelineTrigger" self.pipelines = pipelines @@ -14399,7 +14400,7 @@ def __init__( pipelines=pipelines, **kwargs ) - self.type = "BlobEventsTrigger" # type: str + self.type: str = "BlobEventsTrigger" self.blob_path_begins_with = blob_path_begins_with self.blob_path_ends_with = blob_path_ends_with self.ignore_empty_blobs = ignore_empty_blobs @@ -14535,7 +14536,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "BlobSink" # type: str + self.type: str = "BlobSink" self.blob_writer_overwrite_files = blob_writer_overwrite_files self.blob_writer_date_time_format = blob_writer_date_time_format self.blob_writer_add_header = blob_writer_add_header @@ -14639,7 +14640,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "BlobSource" # type: str + self.type: str = "BlobSource" self.treat_empty_as_null = treat_empty_as_null self.skip_header_line_count = skip_header_line_count self.recursive = recursive @@ -14733,7 +14734,7 @@ def __init__( pipelines=pipelines, **kwargs ) - self.type = "BlobTrigger" # type: str + self.type: str = "BlobTrigger" self.folder_path = folder_path self.max_concurrency = max_concurrency self.linked_service = linked_service @@ -14851,7 +14852,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Cassandra" # type: str + self.type: str = "Cassandra" self.host = host self.authentication_type = authentication_type self.port = port @@ -14976,7 +14977,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "CassandraSource" # type: str + self.type: str = "CassandraSource" self.query = query self.consistency_level = consistency_level @@ -15089,7 +15090,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "CassandraTable" # type: str + self.type: str = "CassandraTable" self.table_name = table_name self.keyspace = keyspace @@ -15173,7 +15174,7 @@ def __init__( super().__init__( additional_properties=additional_properties, description=description, annotations=annotations, **kwargs ) - self.type = "ChainingTrigger" # type: str + self.type: str = "ChainingTrigger" self.pipeline = pipeline self.depends_on = depends_on self.run_dimension = run_dimension @@ -15271,7 +15272,7 @@ def __init__(self, *, target_name: JSON, user_name: JSON, password: "_models.Sec :paramtype password: ~azure.mgmt.datafactory.models.SecretBase """ super().__init__(**kwargs) - self.type = "CmdkeySetup" # type: str + self.type: str = "CmdkeySetup" self.target_name = target_name self.user_name = user_name self.password = password @@ -15399,7 +15400,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "CommonDataServiceForAppsEntity" # type: str + self.type: str = "CommonDataServiceForAppsEntity" self.entity_name = entity_name @@ -15591,7 +15592,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "CommonDataServiceForApps" # type: str + self.type: str = "CommonDataServiceForApps" self.deployment_type = deployment_type self.host_name = host_name self.port = port @@ -15721,7 +15722,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "CommonDataServiceForAppsSink" # type: str + self.type: str = "CommonDataServiceForAppsSink" self.write_behavior = write_behavior self.ignore_null_values = ignore_null_values self.alternate_key_name = alternate_key_name @@ -15815,7 +15816,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "CommonDataServiceForAppsSource" # type: str + self.type: str = "CommonDataServiceForAppsSource" self.query = query self.additional_columns = additional_columns @@ -15852,7 +15853,7 @@ def __init__(self, *, component_name: str, license_key: Optional["_models.Secret :paramtype license_key: ~azure.mgmt.datafactory.models.SecretBase """ super().__init__(**kwargs) - self.type = "ComponentSetup" # type: str + self.type: str = "ComponentSetup" self.component_name = component_name self.license_key = license_key @@ -15897,7 +15898,7 @@ def __init__(self, *, additional_properties: Optional[Dict[str, JSON]] = None, * """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None class ConcurLinkedService(LinkedService): # pylint: disable=too-many-instance-attributes @@ -16030,7 +16031,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Concur" # type: str + self.type: str = "Concur" self.connection_properties = connection_properties self.client_id = client_id self.username = username @@ -16139,7 +16140,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "ConcurObject" # type: str + self.type: str = "ConcurObject" self.table_name = table_name @@ -16241,7 +16242,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "ConcurSource" # type: str + self.type: str = "ConcurSource" self.query = query @@ -16482,7 +16483,7 @@ def __init__( # pylint: disable=too-many-locals policy=policy, **kwargs ) - self.type = "Copy" # type: str + self.type: str = "Copy" self.inputs = inputs self.outputs = outputs self.source = source @@ -16566,7 +16567,7 @@ def __init__(self, *, additional_properties: Optional[Dict[str, JSON]] = None, * """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None class CosmosDbLinkedService(LinkedService): # pylint: disable=too-many-instance-attributes @@ -16744,7 +16745,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "CosmosDb" # type: str + self.type: str = "CosmosDb" self.connection_string = connection_string self.account_endpoint = account_endpoint self.database = database @@ -16860,7 +16861,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "CosmosDbMongoDbApiCollection" # type: str + self.type: str = "CosmosDbMongoDbApiCollection" self.collection = collection @@ -16956,7 +16957,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "CosmosDbMongoDbApi" # type: str + self.type: str = "CosmosDbMongoDbApi" self.is_server_version_above32 = is_server_version_above32 self.connection_string = connection_string self.database = database @@ -17062,7 +17063,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "CosmosDbMongoDbApiSink" # type: str + self.type: str = "CosmosDbMongoDbApiSink" self.write_behavior = write_behavior @@ -17182,7 +17183,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "CosmosDbMongoDbApiSource" # type: str + self.type: str = "CosmosDbMongoDbApiSource" self.filter = filter self.cursor_methods = cursor_methods self.batch_size = batch_size @@ -17291,7 +17292,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "CosmosDbSqlApiCollection" # type: str + self.type: str = "CosmosDbSqlApiCollection" self.collection_name = collection_name @@ -17393,7 +17394,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "CosmosDbSqlApiSink" # type: str + self.type: str = "CosmosDbSqlApiSink" self.write_behavior = write_behavior @@ -17507,7 +17508,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "CosmosDbSqlApiSource" # type: str + self.type: str = "CosmosDbSqlApiSource" self.query = query self.page_size = page_size self.preferred_regions = preferred_regions @@ -17603,7 +17604,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Couchbase" # type: str + self.type: str = "Couchbase" self.connection_string = connection_string self.cred_string = cred_string self.encrypted_credential = encrypted_credential @@ -17707,7 +17708,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "CouchbaseSource" # type: str + self.type: str = "CouchbaseSource" self.query = query @@ -17809,7 +17810,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "CouchbaseTable" # type: str + self.type: str = "CouchbaseTable" self.table_name = table_name @@ -18021,11 +18022,45 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.description = description self.annotations = annotations +class CredentialListResponse(_serialization.Model): + """A list of credential resources. + + All required parameters must be populated in order to send to Azure. + + :ivar value: List of credentials. Required. + :vartype value: list[~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource] + :ivar next_link: The link to the next page of results, if any remaining results exist. + :vartype next_link: str + """ + + _validation = { + "value": {"required": True}, + } + + _attribute_map = { + "value": {"key": "value", "type": "[ManagedIdentityCredentialResource]"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__( + self, *, value: List["_models.ManagedIdentityCredentialResource"], next_link: Optional[str] = None, **kwargs + ): + """ + :keyword value: List of credentials. Required. + :paramtype value: list[~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource] + :keyword next_link: The link to the next page of results, if any remaining results exist. + :paramtype next_link: str + """ + super().__init__(**kwargs) + self.value = value + self.next_link = next_link + + class CredentialReference(_serialization.Model): """Credential reference type. @@ -18290,7 +18325,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "Custom" # type: str + self.type: str = "Custom" self.command = command self.resource_linked_service = resource_linked_service self.folder_path = folder_path @@ -18430,7 +18465,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "CustomDataset" # type: str + self.type: str = "CustomDataset" self.type_properties = type_properties @@ -18505,7 +18540,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "CustomDataSource" # type: str + self.type: str = "CustomDataSource" self.type_properties = type_properties @@ -18603,7 +18638,7 @@ def __init__( pipelines=pipelines, **kwargs ) - self.type = "CustomEventsTrigger" # type: str + self.type: str = "CustomEventsTrigger" self.subject_begins_with = subject_begins_with self.subject_ends_with = subject_ends_with self.events = events @@ -18715,7 +18750,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "DatabricksNotebook" # type: str + self.type: str = "DatabricksNotebook" self.notebook_path = notebook_path self.base_parameters = base_parameters self.libraries = libraries @@ -18824,7 +18859,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "DatabricksSparkJar" # type: str + self.type: str = "DatabricksSparkJar" self.main_class_name = main_class_name self.parameters = parameters self.libraries = libraries @@ -18931,7 +18966,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "DatabricksSparkPython" # type: str + self.type: str = "DatabricksSparkPython" self.python_file = python_file self.parameters = parameters self.libraries = libraries @@ -18989,7 +19024,7 @@ def __init__( :paramtype folder: ~azure.mgmt.datafactory.models.DataFlowFolder """ super().__init__(**kwargs) - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.description = description self.annotations = annotations self.folder = folder @@ -19941,7 +19976,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "DataLakeAnalyticsU-SQL" # type: str + self.type: str = "DataLakeAnalyticsU-SQL" self.script_path = script_path self.script_linked_service = script_linked_service self.degree_of_parallelism = degree_of_parallelism @@ -20323,7 +20358,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Dataworld" # type: str + self.type: str = "Dataworld" self.api_token = api_token self.encrypted_credential = encrypted_credential @@ -20468,7 +20503,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Db2" # type: str + self.type: str = "Db2" self.connection_string = connection_string self.server = server self.database = database @@ -20576,7 +20611,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "Db2Source" # type: str + self.type: str = "Db2Source" self.query = query @@ -20694,7 +20729,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Db2Table" # type: str + self.type: str = "Db2Table" self.table_name = table_name self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -20825,7 +20860,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "Delete" # type: str + self.type: str = "Delete" self.recursive = recursive self.max_concurrent_connections = max_concurrent_connections self.enable_logging = enable_logging @@ -21024,7 +21059,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "DelimitedText" # type: str + self.type: str = "DelimitedText" self.location = location self.column_delimiter = column_delimiter self.row_delimiter = row_delimiter @@ -21084,7 +21119,7 @@ def __init__( :paramtype compression_properties: ~azure.mgmt.datafactory.models.CompressionReadSettings """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "DelimitedTextReadSettings" # type: str + self.type: str = "DelimitedTextReadSettings" self.skip_line_count = skip_line_count self.compression_properties = compression_properties @@ -21191,7 +21226,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "DelimitedTextSink" # type: str + self.type: str = "DelimitedTextSink" self.store_settings = store_settings self.format_settings = format_settings @@ -21288,7 +21323,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "DelimitedTextSource" # type: str + self.type: str = "DelimitedTextSource" self.store_settings = store_settings self.format_settings = format_settings self.additional_columns = additional_columns @@ -21362,7 +21397,7 @@ def __init__( :paramtype file_name_prefix: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "DelimitedTextWriteSettings" # type: str + self.type: str = "DelimitedTextWriteSettings" self.quote_all_text = quote_all_text self.file_extension = file_extension self.max_rows_per_file = max_rows_per_file @@ -21399,7 +21434,7 @@ class DependencyReference(_serialization.Model): def __init__(self, **kwargs): """ """ super().__init__(**kwargs) - self.type = None # type: Optional[str] + self.type: Optional[str] = None class DistcpSettings(_serialization.Model): @@ -21557,7 +21592,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "DocumentDbCollection" # type: str + self.type: str = "DocumentDbCollection" self.collection_name = collection_name @@ -21667,7 +21702,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "DocumentDbCollectionSink" # type: str + self.type: str = "DocumentDbCollectionSink" self.nesting_separator = nesting_separator self.write_behavior = write_behavior @@ -21774,7 +21809,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "DocumentDbCollectionSource" # type: str + self.type: str = "DocumentDbCollectionSource" self.query = query self.nesting_separator = nesting_separator self.query_timeout = query_timeout @@ -21869,7 +21904,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Drill" # type: str + self.type: str = "Drill" self.connection_string = connection_string self.pwd = pwd self.encrypted_credential = encrypted_credential @@ -21973,7 +22008,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "DrillSource" # type: str + self.type: str = "DrillSource" self.query = query @@ -22092,7 +22127,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "DrillTable" # type: str + self.type: str = "DrillTable" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -22291,7 +22326,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "DynamicsAX" # type: str + self.type: str = "DynamicsAX" self.url = url self.service_principal_id = service_principal_id self.service_principal_key = service_principal_key @@ -22401,7 +22436,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "DynamicsAXResource" # type: str + self.type: str = "DynamicsAXResource" self.path = path @@ -22515,7 +22550,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "DynamicsAXSource" # type: str + self.type: str = "DynamicsAXSource" self.query = query self.http_request_timeout = http_request_timeout @@ -22620,7 +22655,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "DynamicsCrmEntity" # type: str + self.type: str = "DynamicsCrmEntity" self.entity_name = entity_name @@ -22805,7 +22840,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "DynamicsCrm" # type: str + self.type: str = "DynamicsCrm" self.deployment_type = deployment_type self.host_name = host_name self.port = port @@ -22935,7 +22970,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "DynamicsCrmSink" # type: str + self.type: str = "DynamicsCrmSink" self.write_behavior = write_behavior self.ignore_null_values = ignore_null_values self.alternate_key_name = alternate_key_name @@ -23029,7 +23064,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "DynamicsCrmSource" # type: str + self.type: str = "DynamicsCrmSource" self.query = query self.additional_columns = additional_columns @@ -23134,7 +23169,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "DynamicsEntity" # type: str + self.type: str = "DynamicsEntity" self.entity_name = entity_name @@ -23324,7 +23359,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Dynamics" # type: str + self.type: str = "Dynamics" self.deployment_type = deployment_type self.host_name = host_name self.port = port @@ -23455,7 +23490,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "DynamicsSink" # type: str + self.type: str = "DynamicsSink" self.write_behavior = write_behavior self.ignore_null_values = ignore_null_values self.alternate_key_name = alternate_key_name @@ -23549,7 +23584,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "DynamicsSource" # type: str + self.type: str = "DynamicsSource" self.query = query self.additional_columns = additional_columns @@ -23676,7 +23711,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Eloqua" # type: str + self.type: str = "Eloqua" self.endpoint = endpoint self.username = username self.password = password @@ -23784,7 +23819,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "EloquaObject" # type: str + self.type: str = "EloquaObject" self.table_name = table_name @@ -23886,7 +23921,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "EloquaSource" # type: str + self.type: str = "EloquaSource" self.query = query @@ -24016,7 +24051,7 @@ def __init__(self, *, variable_name: str, variable_value: str, **kwargs): :paramtype variable_value: str """ super().__init__(**kwargs) - self.type = "EnvironmentVariableSetup" # type: str + self.type: str = "EnvironmentVariableSetup" self.variable_name = variable_name self.variable_value = variable_value @@ -24166,7 +24201,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Excel" # type: str + self.type: str = "Excel" self.location = location self.sheet_name = sheet_name self.sheet_index = sheet_index @@ -24262,7 +24297,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "ExcelSource" # type: str + self.type: str = "ExcelSource" self.store_settings = store_settings self.additional_columns = additional_columns @@ -24405,7 +24440,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "ExecuteDataFlow" # type: str + self.type: str = "ExecuteDataFlow" self.data_flow = data_flow self.staging = staging self.integration_runtime = integration_runtime @@ -24631,7 +24666,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "ExecutePipeline" # type: str + self.type: str = "ExecutePipeline" self.policy = policy self.pipeline = pipeline self.parameters = parameters @@ -24951,7 +24986,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "ExecuteSSISPackage" # type: str + self.type: str = "ExecuteSSISPackage" self.package_location = package_location self.runtime = runtime self.logging_level = logging_level @@ -25110,7 +25145,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "ExecuteWranglingDataflow" # type: str + self.type: str = "ExecuteWranglingDataflow" self.policy = policy self.data_flow = data_flow self.staging = staging @@ -25515,7 +25550,7 @@ def __init__( :paramtype disable_publish: bool """ super().__init__(**kwargs) - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.account_name = account_name self.repository_name = repository_name self.collaboration_branch = collaboration_branch @@ -25617,7 +25652,7 @@ def __init__( disable_publish=disable_publish, **kwargs ) - self.type = "FactoryGitHubConfiguration" # type: str + self.type: str = "FactoryGitHubConfiguration" self.host_name = host_name self.client_id = client_id self.client_secret = client_secret @@ -25868,7 +25903,7 @@ def __init__( disable_publish=disable_publish, **kwargs ) - self.type = "FactoryVSTSConfiguration" # type: str + self.type: str = "FactoryVSTSConfiguration" self.project_name = project_name self.tenant_id = tenant_id @@ -25960,7 +25995,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "Fail" # type: str + self.type: str = "Fail" self.message = message self.error_code = error_code @@ -26062,7 +26097,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "FileServer" # type: str + self.type: str = "FileServer" self.host = host self.user_id = user_id self.password = password @@ -26120,7 +26155,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "FileServerLocation" # type: str + self.type: str = "FileServerLocation" class FileServerReadSettings(StoreReadSettings): # pylint: disable=too-many-instance-attributes @@ -26257,7 +26292,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "FileServerReadSettings" # type: str + self.type: str = "FileServerReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -26331,7 +26366,7 @@ def __init__( copy_behavior=copy_behavior, **kwargs ) - self.type = "FileServerWriteSettings" # type: str + self.type: str = "FileServerWriteSettings" class FileShareDataset(Dataset): # pylint: disable=too-many-instance-attributes @@ -26478,7 +26513,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "FileShare" # type: str + self.type: str = "FileShare" self.folder_path = folder_path self.file_name = file_name self.modified_datetime_start = modified_datetime_start @@ -26584,7 +26619,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "FileSystemSink" # type: str + self.type: str = "FileSystemSink" self.copy_behavior = copy_behavior @@ -26676,7 +26711,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "FileSystemSource" # type: str + self.type: str = "FileSystemSource" self.recursive = recursive self.additional_columns = additional_columns @@ -26760,7 +26795,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "Filter" # type: str + self.type: str = "Filter" self.items = items self.condition = condition @@ -26840,7 +26875,7 @@ def __init__( :paramtype script_lines: list[str] """ super().__init__(description=description, annotations=annotations, folder=folder, **kwargs) - self.type = "Flowlet" # type: str + self.type: str = "Flowlet" self.sources = sources self.sinks = sinks self.transformations = transformations @@ -26942,7 +26977,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "ForEach" # type: str + self.type: str = "ForEach" self.is_sequential = is_sequential self.batch_count = batch_count self.items = items @@ -27073,7 +27108,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "FtpReadSettings" # type: str + self.type: str = "FtpReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -27219,7 +27254,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "FtpServer" # type: str + self.type: str = "FtpServer" self.host = host self.port = port self.authentication_type = authentication_type @@ -27281,7 +27316,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "FtpServerLocation" # type: str + self.type: str = "FtpServerLocation" class GetDataFactoryOperationStatusResponse(_serialization.Model): @@ -27418,7 +27453,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "GetMetadata" # type: str + self.type: str = "GetMetadata" self.dataset = dataset self.field_list = field_list self.store_settings = store_settings @@ -27823,7 +27858,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "GoogleAdWords" # type: str + self.type: str = "GoogleAdWords" self.connection_properties = connection_properties self.client_customer_id = client_customer_id self.developer_token = developer_token @@ -27936,7 +27971,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "GoogleAdWordsObject" # type: str + self.type: str = "GoogleAdWordsObject" self.table_name = table_name @@ -28038,7 +28073,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "GoogleAdWordsSource" # type: str + self.type: str = "GoogleAdWordsSource" self.query = query @@ -28210,7 +28245,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "GoogleBigQuery" # type: str + self.type: str = "GoogleBigQuery" self.project = project self.additional_projects = additional_projects self.request_google_drive_scope = request_google_drive_scope @@ -28341,7 +28376,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "GoogleBigQueryObject" # type: str + self.type: str = "GoogleBigQueryObject" self.table_name = table_name self.table = table self.dataset = dataset @@ -28445,7 +28480,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "GoogleBigQuerySource" # type: str + self.type: str = "GoogleBigQuerySource" self.query = query @@ -28551,7 +28586,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "GoogleCloudStorage" # type: str + self.type: str = "GoogleCloudStorage" self.access_key_id = access_key_id self.secret_access_key = secret_access_key self.service_url = service_url @@ -28625,7 +28660,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "GoogleCloudStorageLocation" # type: str + self.type: str = "GoogleCloudStorageLocation" self.bucket_name = bucket_name self.version = version @@ -28764,7 +28799,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "GoogleCloudStorageReadSettings" # type: str + self.type: str = "GoogleCloudStorageReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -28858,7 +28893,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "GoogleSheets" # type: str + self.type: str = "GoogleSheets" self.api_token = api_token self.encrypted_credential = encrypted_credential @@ -28951,7 +28986,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Greenplum" # type: str + self.type: str = "Greenplum" self.connection_string = connection_string self.pwd = pwd self.encrypted_credential = encrypted_credential @@ -29055,7 +29090,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "GreenplumSource" # type: str + self.type: str = "GreenplumSource" self.query = query @@ -29174,7 +29209,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "GreenplumTable" # type: str + self.type: str = "GreenplumTable" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -29333,7 +29368,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "HBase" # type: str + self.type: str = "HBase" self.host = host self.port = port self.http_path = http_path @@ -29445,7 +29480,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "HBaseObject" # type: str + self.type: str = "HBaseObject" self.table_name = table_name @@ -29547,7 +29582,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "HBaseSource" # type: str + self.type: str = "HBaseSource" self.query = query @@ -29656,7 +29691,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Hdfs" # type: str + self.type: str = "Hdfs" self.url = url self.authentication_type = authentication_type self.encrypted_credential = encrypted_credential @@ -29715,7 +29750,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "HdfsLocation" # type: str + self.type: str = "HdfsLocation" class HdfsReadSettings(StoreReadSettings): # pylint: disable=too-many-instance-attributes @@ -29850,7 +29885,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "HdfsReadSettings" # type: str + self.type: str = "HdfsReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -29949,7 +29984,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "HdfsSource" # type: str + self.type: str = "HdfsSource" self.recursive = recursive self.distcp_settings = distcp_settings @@ -30084,7 +30119,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "HDInsightHive" # type: str + self.type: str = "HDInsightHive" self.storage_linked_services = storage_linked_services self.arguments = arguments self.get_debug_info = get_debug_info @@ -30225,7 +30260,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "HDInsight" # type: str + self.type: str = "HDInsight" self.cluster_uri = cluster_uri self.user_name = user_name self.password = password @@ -30367,7 +30402,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "HDInsightMapReduce" # type: str + self.type: str = "HDInsightMapReduce" self.storage_linked_services = storage_linked_services self.arguments = arguments self.get_debug_info = get_debug_info @@ -30724,7 +30759,7 @@ def __init__( # pylint: disable=too-many-locals annotations=annotations, **kwargs ) - self.type = "HDInsightOnDemand" # type: str + self.type: str = "HDInsightOnDemand" self.cluster_size = cluster_size self.time_to_live = time_to_live self.version = version @@ -30879,7 +30914,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "HDInsightPig" # type: str + self.type: str = "HDInsightPig" self.storage_linked_services = storage_linked_services self.arguments = arguments self.get_debug_info = get_debug_info @@ -31026,7 +31061,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "HDInsightSpark" # type: str + self.type: str = "HDInsightSpark" self.root_path = root_path self.entry_file_path = entry_file_path self.arguments = arguments @@ -31200,7 +31235,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "HDInsightStreaming" # type: str + self.type: str = "HDInsightStreaming" self.storage_linked_services = storage_linked_services self.arguments = arguments self.get_debug_info = get_debug_info @@ -31417,7 +31452,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Hive" # type: str + self.type: str = "Hive" self.host = host self.port = port self.server_type = server_type @@ -31552,7 +31587,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "HiveObject" # type: str + self.type: str = "HiveObject" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -31656,7 +31691,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "HiveSource" # type: str + self.type: str = "HiveSource" self.query = query @@ -31802,7 +31837,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "HttpFile" # type: str + self.type: str = "HttpFile" self.relative_url = relative_url self.request_method = request_method self.request_body = request_body @@ -31961,7 +31996,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "HttpServer" # type: str + self.type: str = "HttpServer" self.url = url self.authentication_type = authentication_type self.user_name = user_name @@ -32073,7 +32108,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "HttpReadSettings" # type: str + self.type: str = "HttpReadSettings" self.request_method = request_method self.request_body = request_body self.additional_headers = additional_headers @@ -32141,7 +32176,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "HttpServerLocation" # type: str + self.type: str = "HttpServerLocation" self.relative_url = relative_url @@ -32229,7 +32264,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "HttpSource" # type: str + self.type: str = "HttpSource" self.http_request_timeout = http_request_timeout @@ -32362,7 +32397,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Hubspot" # type: str + self.type: str = "Hubspot" self.client_id = client_id self.client_secret = client_secret self.access_token = access_token @@ -32471,7 +32506,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "HubspotObject" # type: str + self.type: str = "HubspotObject" self.table_name = table_name @@ -32573,7 +32608,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "HubspotSource" # type: str + self.type: str = "HubspotSource" self.query = query @@ -32669,7 +32704,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "IfCondition" # type: str + self.type: str = "IfCondition" self.expression = expression self.if_true_activities = if_true_activities self.if_false_activities = if_false_activities @@ -32830,7 +32865,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Impala" # type: str + self.type: str = "Impala" self.host = host self.port = port self.authentication_type = authentication_type @@ -32959,7 +32994,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "ImpalaObject" # type: str + self.type: str = "ImpalaObject" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -33063,7 +33098,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "ImpalaSource" # type: str + self.type: str = "ImpalaSource" self.query = query @@ -33184,7 +33219,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Informix" # type: str + self.type: str = "Informix" self.connection_string = connection_string self.authentication_type = authentication_type self.credential = credential @@ -33291,7 +33326,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "InformixSink" # type: str + self.type: str = "InformixSink" self.pre_copy_script = pre_copy_script @@ -33391,7 +33426,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "InformixSource" # type: str + self.type: str = "InformixSource" self.query = query @@ -33494,7 +33529,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "InformixTable" # type: str + self.type: str = "InformixTable" self.table_name = table_name @@ -33540,7 +33575,7 @@ def __init__( """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.description = description @@ -34509,7 +34544,7 @@ def __init__(self, *, additional_properties: Optional[Dict[str, JSON]] = None, * """ super().__init__(**kwargs) self.additional_properties = additional_properties - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.data_factory_name = None self.state = None @@ -34770,7 +34805,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Jira" # type: str + self.type: str = "Jira" self.host = host self.port = port self.username = username @@ -34879,7 +34914,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "JiraObject" # type: str + self.type: str = "JiraObject" self.table_name = table_name @@ -34981,7 +35016,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "JiraSource" # type: str + self.type: str = "JiraSource" self.query = query @@ -35103,7 +35138,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Json" # type: str + self.type: str = "Json" self.location = location self.encoding_name = encoding_name self.compression = compression @@ -35208,7 +35243,7 @@ def __init__( super().__init__( additional_properties=additional_properties, serializer=serializer, deserializer=deserializer, **kwargs ) - self.type = "JsonFormat" # type: str + self.type: str = "JsonFormat" self.file_pattern = file_pattern self.nesting_separator = nesting_separator self.encoding_name = encoding_name @@ -35255,7 +35290,7 @@ def __init__( :paramtype compression_properties: ~azure.mgmt.datafactory.models.CompressionReadSettings """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "JsonReadSettings" # type: str + self.type: str = "JsonReadSettings" self.compression_properties = compression_properties @@ -35361,7 +35396,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "JsonSink" # type: str + self.type: str = "JsonSink" self.store_settings = store_settings self.format_settings = format_settings @@ -35458,7 +35493,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "JsonSource" # type: str + self.type: str = "JsonSource" self.store_settings = store_settings self.format_settings = format_settings self.additional_columns = additional_columns @@ -35501,7 +35536,7 @@ def __init__( :paramtype file_pattern: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "JsonWriteSettings" # type: str + self.type: str = "JsonWriteSettings" self.file_pattern = file_pattern @@ -35580,7 +35615,7 @@ class LinkedIntegrationRuntimeType(_serialization.Model): def __init__(self, **kwargs): """ """ super().__init__(**kwargs) - self.authorization_type = None # type: Optional[str] + self.authorization_type: Optional[str] = None class LinkedIntegrationRuntimeKeyAuthorization(LinkedIntegrationRuntimeType): @@ -35610,7 +35645,7 @@ def __init__(self, *, key: "_models.SecureString", **kwargs): :paramtype key: ~azure.mgmt.datafactory.models.SecureString """ super().__init__(**kwargs) - self.authorization_type = "Key" # type: str + self.authorization_type: str = "Key" self.key = key @@ -35647,7 +35682,7 @@ def __init__(self, *, resource_id: str, credential: Optional["_models.Credential :paramtype credential: ~azure.mgmt.datafactory.models.CredentialReference """ super().__init__(**kwargs) - self.authorization_type = "RBAC" # type: str + self.authorization_type: str = "RBAC" self.resource_id = resource_id self.credential = credential @@ -36082,7 +36117,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "Lookup" # type: str + self.type: str = "Lookup" self.source = source self.dataset = dataset self.first_row_only = first_row_only @@ -36201,7 +36236,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Magento" # type: str + self.type: str = "Magento" self.host = host self.access_token = access_token self.use_encrypted_endpoints = use_encrypted_endpoints @@ -36308,7 +36343,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "MagentoObject" # type: str + self.type: str = "MagentoObject" self.table_name = table_name @@ -36410,7 +36445,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "MagentoSource" # type: str + self.type: str = "MagentoSource" self.query = query @@ -36467,10 +36502,54 @@ def __init__( super().__init__( additional_properties=additional_properties, description=description, annotations=annotations, **kwargs ) - self.type = "ManagedIdentity" # type: str + self.type: str = "ManagedIdentity" self.resource_id = resource_id +class ManagedIdentityCredentialResource(SubResource): + """Credential resource type. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to Azure. + + :ivar id: The resource identifier. + :vartype id: str + :ivar name: The resource name. + :vartype name: str + :ivar type: The resource type. + :vartype type: str + :ivar etag: Etag identifies change in the resource. + :vartype etag: str + :ivar properties: Managed Identity Credential properties. Required. + :vartype properties: ~azure.mgmt.datafactory.models.ManagedIdentityCredential + """ + + _validation = { + "id": {"readonly": True}, + "name": {"readonly": True}, + "type": {"readonly": True}, + "etag": {"readonly": True}, + "properties": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "etag": {"key": "etag", "type": "str"}, + "properties": {"key": "properties", "type": "ManagedIdentityCredential"}, + } + + def __init__(self, *, properties: "_models.ManagedIdentityCredential", **kwargs): + """ + :keyword properties: Managed Identity Credential properties. Required. + :paramtype properties: ~azure.mgmt.datafactory.models.ManagedIdentityCredential + """ + super().__init__(**kwargs) + self.properties = properties + + class ManagedIntegrationRuntime(IntegrationRuntime): """Managed integration runtime, including managed elastic and managed dedicated integration runtimes. @@ -36555,7 +36634,7 @@ def __init__( ~azure.mgmt.datafactory.models.IntegrationRuntimeCustomerVirtualNetwork """ super().__init__(additional_properties=additional_properties, description=description, **kwargs) - self.type = "Managed" # type: str + self.type: str = "Managed" self.state = None self.managed_virtual_network = managed_virtual_network self.compute_properties = compute_properties @@ -36775,7 +36854,7 @@ def __init__(self, *, additional_properties: Optional[Dict[str, JSON]] = None, * :paramtype additional_properties: dict[str, JSON] """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "Managed" # type: str + self.type: str = "Managed" self.create_time = None self.nodes = None self.other_errors = None @@ -37158,7 +37237,7 @@ def __init__( :paramtype script_lines: list[str] """ super().__init__(description=description, annotations=annotations, folder=folder, **kwargs) - self.type = "MappingDataFlow" # type: str + self.type: str = "MappingDataFlow" self.sources = sources self.sinks = sinks self.transformations = transformations @@ -37254,7 +37333,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "MariaDB" # type: str + self.type: str = "MariaDB" self.connection_string = connection_string self.pwd = pwd self.encrypted_credential = encrypted_credential @@ -37358,7 +37437,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "MariaDBSource" # type: str + self.type: str = "MariaDBSource" self.query = query @@ -37460,7 +37539,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "MariaDBTable" # type: str + self.type: str = "MariaDBTable" self.table_name = table_name @@ -37585,7 +37664,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Marketo" # type: str + self.type: str = "Marketo" self.endpoint = endpoint self.client_id = client_id self.client_secret = client_secret @@ -37693,7 +37772,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "MarketoObject" # type: str + self.type: str = "MarketoObject" self.table_name = table_name @@ -37795,7 +37874,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "MarketoSource" # type: str + self.type: str = "MarketoSource" self.query = query @@ -37942,7 +38021,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "MicrosoftAccess" # type: str + self.type: str = "MicrosoftAccess" self.connection_string = connection_string self.authentication_type = authentication_type self.credential = credential @@ -38049,7 +38128,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "MicrosoftAccessSink" # type: str + self.type: str = "MicrosoftAccessSink" self.pre_copy_script = pre_copy_script @@ -38139,7 +38218,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "MicrosoftAccessSource" # type: str + self.type: str = "MicrosoftAccessSource" self.query = query self.additional_columns = additional_columns @@ -38244,7 +38323,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "MicrosoftAccessTable" # type: str + self.type: str = "MicrosoftAccessTable" self.table_name = table_name @@ -38349,7 +38428,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "MongoDbAtlasCollection" # type: str + self.type: str = "MongoDbAtlasCollection" self.collection = collection @@ -38437,7 +38516,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "MongoDbAtlas" # type: str + self.type: str = "MongoDbAtlas" self.connection_string = connection_string self.database = database @@ -38542,7 +38621,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "MongoDbAtlasSink" # type: str + self.type: str = "MongoDbAtlasSink" self.write_behavior = write_behavior @@ -38662,7 +38741,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "MongoDbAtlasSource" # type: str + self.type: str = "MongoDbAtlasSource" self.filter = filter self.cursor_methods = cursor_methods self.batch_size = batch_size @@ -38771,7 +38850,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "MongoDbCollection" # type: str + self.type: str = "MongoDbCollection" self.collection_name = collection_name @@ -38992,7 +39071,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "MongoDb" # type: str + self.type: str = "MongoDb" self.server = server self.authentication_type = authentication_type self.database_name = database_name @@ -39093,7 +39172,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "MongoDbSource" # type: str + self.type: str = "MongoDbSource" self.query = query self.additional_columns = additional_columns @@ -39199,7 +39278,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "MongoDbV2Collection" # type: str + self.type: str = "MongoDbV2Collection" self.collection = collection @@ -39287,7 +39366,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "MongoDbV2" # type: str + self.type: str = "MongoDbV2" self.connection_string = connection_string self.database = database @@ -39392,7 +39471,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "MongoDbV2Sink" # type: str + self.type: str = "MongoDbV2Sink" self.write_behavior = write_behavior @@ -39512,7 +39591,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "MongoDbV2Source" # type: str + self.type: str = "MongoDbV2Source" self.filter = filter self.cursor_methods = cursor_methods self.batch_size = batch_size @@ -39607,7 +39686,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "MySql" # type: str + self.type: str = "MySql" self.connection_string = connection_string self.password = password self.encrypted_credential = encrypted_credential @@ -39709,7 +39788,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "MySqlSource" # type: str + self.type: str = "MySqlSource" self.query = query @@ -39811,7 +39890,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "MySqlTable" # type: str + self.type: str = "MySqlTable" self.table_name = table_name @@ -39903,7 +39982,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Netezza" # type: str + self.type: str = "Netezza" self.connection_string = connection_string self.pwd = pwd self.encrypted_credential = encrypted_credential @@ -40071,7 +40150,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "NetezzaSource" # type: str + self.type: str = "NetezzaSource" self.query = query self.partition_option = partition_option self.partition_settings = partition_settings @@ -40193,7 +40272,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "NetezzaTable" # type: str + self.type: str = "NetezzaTable" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -40426,7 +40505,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "OData" # type: str + self.type: str = "OData" self.url = url self.authentication_type = authentication_type self.user_name = user_name @@ -40541,7 +40620,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "ODataResource" # type: str + self.type: str = "ODataResource" self.path = path @@ -40645,7 +40724,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "ODataSource" # type: str + self.type: str = "ODataSource" self.query = query self.http_request_timeout = http_request_timeout self.additional_columns = additional_columns @@ -40766,7 +40845,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Odbc" # type: str + self.type: str = "Odbc" self.connection_string = connection_string self.authentication_type = authentication_type self.credential = credential @@ -40873,7 +40952,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "OdbcSink" # type: str + self.type: str = "OdbcSink" self.pre_copy_script = pre_copy_script @@ -40973,7 +41052,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "OdbcSource" # type: str + self.type: str = "OdbcSource" self.query = query @@ -41075,7 +41154,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "OdbcTable" # type: str + self.type: str = "OdbcTable" self.table_name = table_name @@ -41188,7 +41267,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Office365Table" # type: str + self.type: str = "Office365Table" self.table_name = table_name self.predicate = predicate @@ -41301,7 +41380,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Office365" # type: str + self.type: str = "Office365" self.office365_tenant_id = office365_tenant_id self.service_principal_tenant_id = service_principal_tenant_id self.service_principal_id = service_principal_id @@ -41431,7 +41510,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "Office365Source" # type: str + self.type: str = "Office365Source" self.allowed_groups = allowed_groups self.user_scope_filter_uri = user_scope_filter_uri self.date_filter_column = date_filter_column @@ -41888,7 +41967,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "OracleCloudStorage" # type: str + self.type: str = "OracleCloudStorage" self.access_key_id = access_key_id self.secret_access_key = secret_access_key self.service_url = service_url @@ -41962,7 +42041,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "OracleCloudStorageLocation" # type: str + self.type: str = "OracleCloudStorageLocation" self.bucket_name = bucket_name self.version = version @@ -42101,7 +42180,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "OracleCloudStorageReadSettings" # type: str + self.type: str = "OracleCloudStorageReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -42203,7 +42282,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Oracle" # type: str + self.type: str = "Oracle" self.connection_string = connection_string self.password = password self.encrypted_credential = encrypted_credential @@ -42390,7 +42469,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "OracleServiceCloud" # type: str + self.type: str = "OracleServiceCloud" self.host = host self.username = username self.password = password @@ -42498,7 +42577,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "OracleServiceCloudObject" # type: str + self.type: str = "OracleServiceCloudObject" self.table_name = table_name @@ -42600,7 +42679,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "OracleServiceCloudSource" # type: str + self.type: str = "OracleServiceCloudSource" self.query = query @@ -42702,7 +42781,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "OracleSink" # type: str + self.type: str = "OracleSink" self.pre_copy_script = pre_copy_script @@ -42817,7 +42896,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "OracleSource" # type: str + self.type: str = "OracleSource" self.oracle_reader_query = oracle_reader_query self.query_timeout = query_timeout self.partition_option = partition_option @@ -42941,7 +43020,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "OracleTable" # type: str + self.type: str = "OracleTable" self.table_name = table_name self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -43053,7 +43132,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Orc" # type: str + self.type: str = "Orc" self.location = location self.orc_compression_codec = orc_compression_codec @@ -43105,7 +43184,7 @@ def __init__( super().__init__( additional_properties=additional_properties, serializer=serializer, deserializer=deserializer, **kwargs ) - self.type = "OrcFormat" # type: str + self.type: str = "OrcFormat" class OrcSink(CopySink): @@ -43210,7 +43289,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "OrcSink" # type: str + self.type: str = "OrcSink" self.store_settings = store_settings self.format_settings = format_settings @@ -43301,7 +43380,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "OrcSource" # type: str + self.type: str = "OrcSource" self.store_settings = store_settings self.additional_columns = additional_columns @@ -43357,7 +43436,7 @@ def __init__( :paramtype file_name_prefix: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "OrcWriteSettings" # type: str + self.type: str = "OrcWriteSettings" self.max_rows_per_file = max_rows_per_file self.file_name_prefix = file_name_prefix @@ -43535,7 +43614,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Parquet" # type: str + self.type: str = "Parquet" self.location = location self.compression_codec = compression_codec @@ -43587,7 +43666,7 @@ def __init__( super().__init__( additional_properties=additional_properties, serializer=serializer, deserializer=deserializer, **kwargs ) - self.type = "ParquetFormat" # type: str + self.type: str = "ParquetFormat" class ParquetSink(CopySink): @@ -43692,7 +43771,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "ParquetSink" # type: str + self.type: str = "ParquetSink" self.store_settings = store_settings self.format_settings = format_settings @@ -43783,7 +43862,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "ParquetSource" # type: str + self.type: str = "ParquetSource" self.store_settings = store_settings self.additional_columns = additional_columns @@ -43839,7 +43918,7 @@ def __init__( :paramtype file_name_prefix: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "ParquetWriteSettings" # type: str + self.type: str = "ParquetWriteSettings" self.max_rows_per_file = max_rows_per_file self.file_name_prefix = file_name_prefix @@ -43964,7 +44043,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Paypal" # type: str + self.type: str = "Paypal" self.host = host self.client_id = client_id self.client_secret = client_secret @@ -44072,7 +44151,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "PaypalObject" # type: str + self.type: str = "PaypalObject" self.table_name = table_name @@ -44174,7 +44253,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "PaypalSource" # type: str + self.type: str = "PaypalSource" self.query = query @@ -44344,7 +44423,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Phoenix" # type: str + self.type: str = "Phoenix" self.host = host self.port = port self.http_path = http_path @@ -44475,7 +44554,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "PhoenixObject" # type: str + self.type: str = "PhoenixObject" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -44579,7 +44658,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "PhoenixSource" # type: str + self.type: str = "PhoenixSource" self.query = query @@ -45158,7 +45237,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "PostgreSql" # type: str + self.type: str = "PostgreSql" self.connection_string = connection_string self.password = password self.encrypted_credential = encrypted_credential @@ -45260,7 +45339,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "PostgreSqlSource" # type: str + self.type: str = "PostgreSqlSource" self.query = query @@ -45378,12 +45457,95 @@ def __init__( folder=folder, **kwargs ) - self.type = "PostgreSqlTable" # type: str + self.type: str = "PostgreSqlTable" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema +class PowerBILinkedService(LinkedService): + """Power BI linked service. + + All required parameters must be populated in order to send to Azure. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, JSON] + :ivar type: Type of linked service. Required. + :vartype type: str + :ivar connect_via: The integration runtime reference. + :vartype connect_via: ~azure.mgmt.datafactory.models.IntegrationRuntimeReference + :ivar description: Linked service description. + :vartype description: str + :ivar parameters: Parameters for linked service. + :vartype parameters: dict[str, ~azure.mgmt.datafactory.models.ParameterSpecification] + :ivar annotations: List of tags that can be used for describing the linked service. + :vartype annotations: list[JSON] + :ivar workspace_id: The Power BI workspace id. Required. + :vartype workspace_id: str + :ivar tenant_id: The tenant id to which the Power BI workspace belongs. Required. + :vartype tenant_id: str + """ + + _validation = { + "type": {"required": True}, + "workspace_id": {"required": True}, + "tenant_id": {"required": True}, + } + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "type": {"key": "type", "type": "str"}, + "connect_via": {"key": "connectVia", "type": "IntegrationRuntimeReference"}, + "description": {"key": "description", "type": "str"}, + "parameters": {"key": "parameters", "type": "{ParameterSpecification}"}, + "annotations": {"key": "annotations", "type": "[object]"}, + "workspace_id": {"key": "typeProperties.workspaceId", "type": "str"}, + "tenant_id": {"key": "typeProperties.tenantId", "type": "str"}, + } + + def __init__( + self, + *, + workspace_id: str, + tenant_id: str, + additional_properties: Optional[Dict[str, JSON]] = None, + connect_via: Optional["_models.IntegrationRuntimeReference"] = None, + description: Optional[str] = None, + parameters: Optional[Dict[str, "_models.ParameterSpecification"]] = None, + annotations: Optional[List[JSON]] = None, + **kwargs + ): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, JSON] + :keyword connect_via: The integration runtime reference. + :paramtype connect_via: ~azure.mgmt.datafactory.models.IntegrationRuntimeReference + :keyword description: Linked service description. + :paramtype description: str + :keyword parameters: Parameters for linked service. + :paramtype parameters: dict[str, ~azure.mgmt.datafactory.models.ParameterSpecification] + :keyword annotations: List of tags that can be used for describing the linked service. + :paramtype annotations: list[JSON] + :keyword workspace_id: The Power BI workspace id. Required. + :paramtype workspace_id: str + :keyword tenant_id: The tenant id to which the Power BI workspace belongs. Required. + :paramtype tenant_id: str + """ + super().__init__( + additional_properties=additional_properties, + connect_via=connect_via, + description=description, + parameters=parameters, + annotations=annotations, + **kwargs + ) + self.type: str = "PowerBI" + self.workspace_id = workspace_id + self.tenant_id = tenant_id + + class PowerQuerySink(DataFlowSink): """Power query sink. @@ -45748,7 +45910,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Presto" # type: str + self.type: str = "Presto" self.host = host self.server_version = server_version self.catalog = catalog @@ -45880,7 +46042,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "PrestoObject" # type: str + self.type: str = "PrestoObject" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -45984,7 +46146,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "PrestoSource" # type: str + self.type: str = "PrestoSource" self.query = query @@ -46442,7 +46604,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Quickbase" # type: str + self.type: str = "Quickbase" self.url = url self.user_token = user_token self.encrypted_credential = encrypted_credential @@ -46574,7 +46736,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "QuickBooks" # type: str + self.type: str = "QuickBooks" self.connection_properties = connection_properties self.endpoint = endpoint self.company_id = company_id @@ -46684,7 +46846,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "QuickBooksObject" # type: str + self.type: str = "QuickBooksObject" self.table_name = table_name @@ -46786,7 +46948,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "QuickBooksSource" # type: str + self.type: str = "QuickBooksSource" self.query = query @@ -47076,7 +47238,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "RelationalSource" # type: str + self.type: str = "RelationalSource" self.query = query self.additional_columns = additional_columns @@ -47181,7 +47343,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "RelationalTable" # type: str + self.type: str = "RelationalTable" self.table_name = table_name @@ -47320,7 +47482,7 @@ def __init__( super().__init__( additional_properties=additional_properties, description=description, annotations=annotations, **kwargs ) - self.type = "RerunTumblingWindowTrigger" # type: str + self.type: str = "RerunTumblingWindowTrigger" self.parent_trigger = parent_trigger self.requested_start_time = requested_start_time self.requested_end_time = requested_end_time @@ -47453,7 +47615,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Responsys" # type: str + self.type: str = "Responsys" self.endpoint = endpoint self.client_id = client_id self.client_secret = client_secret @@ -47561,7 +47723,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "ResponsysObject" # type: str + self.type: str = "ResponsysObject" self.table_name = table_name @@ -47663,7 +47825,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "ResponsysSource" # type: str + self.type: str = "ResponsysSource" self.query = query @@ -47799,7 +47961,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "RestResource" # type: str + self.type: str = "RestResource" self.relative_url = relative_url self.request_method = request_method self.request_body = request_body @@ -48018,7 +48180,7 @@ def __init__( # pylint: disable=too-many-locals annotations=annotations, **kwargs ) - self.type = "RestService" # type: str + self.type: str = "RestService" self.url = url self.enable_server_certificate_validation = enable_server_certificate_validation self.authentication_type = authentication_type @@ -48171,7 +48333,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "RestSink" # type: str + self.type: str = "RestSink" self.request_method = request_method self.additional_headers = additional_headers self.http_request_timeout = http_request_timeout @@ -48309,7 +48471,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "RestSource" # type: str + self.type: str = "RestSource" self.request_method = request_method self.request_body = request_body self.additional_headers = additional_headers @@ -48639,7 +48801,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Salesforce" # type: str + self.type: str = "Salesforce" self.environment_url = environment_url self.username = username self.password = password @@ -48774,7 +48936,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SalesforceMarketingCloud" # type: str + self.type: str = "SalesforceMarketingCloud" self.connection_properties = connection_properties self.client_id = client_id self.client_secret = client_secret @@ -48882,7 +49044,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SalesforceMarketingCloudObject" # type: str + self.type: str = "SalesforceMarketingCloudObject" self.table_name = table_name @@ -48984,7 +49146,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SalesforceMarketingCloudSource" # type: str + self.type: str = "SalesforceMarketingCloudSource" self.query = query @@ -49088,7 +49250,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SalesforceObject" # type: str + self.type: str = "SalesforceObject" self.object_api_name = object_api_name @@ -49214,7 +49376,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SalesforceServiceCloud" # type: str + self.type: str = "SalesforceServiceCloud" self.environment_url = environment_url self.username = username self.password = password @@ -49324,7 +49486,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SalesforceServiceCloudObject" # type: str + self.type: str = "SalesforceServiceCloudObject" self.object_api_name = object_api_name @@ -49451,7 +49613,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SalesforceServiceCloudSink" # type: str + self.type: str = "SalesforceServiceCloudSink" self.write_behavior = write_behavior self.external_id_field_name = external_id_field_name self.ignore_null_values = ignore_null_values @@ -49551,7 +49713,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SalesforceServiceCloudSource" # type: str + self.type: str = "SalesforceServiceCloudSource" self.query = query self.read_behavior = read_behavior self.additional_columns = additional_columns @@ -49680,7 +49842,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SalesforceSink" # type: str + self.type: str = "SalesforceSink" self.write_behavior = write_behavior self.external_id_field_name = external_id_field_name self.ignore_null_values = ignore_null_values @@ -49790,7 +49952,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SalesforceSource" # type: str + self.type: str = "SalesforceSource" self.query = query self.read_behavior = read_behavior @@ -49887,7 +50049,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SapBwCube" # type: str + self.type: str = "SapBwCube" class SapBWLinkedService(LinkedService): # pylint: disable=too-many-instance-attributes @@ -50005,7 +50167,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SapBW" # type: str + self.type: str = "SapBW" self.server = server self.system_number = system_number self.client_id = client_id @@ -50110,7 +50272,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SapBwSource" # type: str + self.type: str = "SapBwSource" self.query = query @@ -50213,7 +50375,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SapCloudForCustomer" # type: str + self.type: str = "SapCloudForCustomer" self.url = url self.username = username self.password = password @@ -50321,7 +50483,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SapCloudForCustomerResource" # type: str + self.type: str = "SapCloudForCustomerResource" self.path = path @@ -50437,7 +50599,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SapCloudForCustomerSink" # type: str + self.type: str = "SapCloudForCustomerSink" self.write_behavior = write_behavior self.http_request_timeout = http_request_timeout @@ -50552,7 +50714,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SapCloudForCustomerSource" # type: str + self.type: str = "SapCloudForCustomerSource" self.query = query self.http_request_timeout = http_request_timeout @@ -50656,7 +50818,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SapEcc" # type: str + self.type: str = "SapEcc" self.url = url self.username = username self.password = password @@ -50764,7 +50926,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SapEccResource" # type: str + self.type: str = "SapEccResource" self.path = path @@ -50878,7 +51040,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SapEccSource" # type: str + self.type: str = "SapEccSource" self.query = query self.http_request_timeout = http_request_timeout @@ -50995,7 +51157,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SapHana" # type: str + self.type: str = "SapHana" self.connection_string = connection_string self.server = server self.authentication_type = authentication_type @@ -51145,7 +51307,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SapHanaSource" # type: str + self.type: str = "SapHanaSource" self.query = query self.packet_size = packet_size self.partition_option = partition_option @@ -51259,7 +51421,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SapHanaTable" # type: str + self.type: str = "SapHanaTable" self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -51476,7 +51638,7 @@ def __init__( # pylint: disable=too-many-locals annotations=annotations, **kwargs ) - self.type = "SapOdp" # type: str + self.type: str = "SapOdp" self.server = server self.system_number = system_number self.client_id = client_id @@ -51607,7 +51769,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SapOdpResource" # type: str + self.type: str = "SapOdpResource" self.context = context self.object_name = object_name @@ -51734,7 +51896,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SapOdpSource" # type: str + self.type: str = "SapOdpSource" self.extraction_mode = extraction_mode self.subscriber_process = subscriber_process self.selection = selection @@ -51898,7 +52060,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SapOpenHub" # type: str + self.type: str = "SapOpenHub" self.server = server self.system_number = system_number self.client_id = client_id @@ -52038,7 +52200,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SapOpenHubSource" # type: str + self.type: str = "SapOpenHubSource" self.exclude_last_request = exclude_last_request self.base_request_id = base_request_id self.custom_rfc_read_table_function_module = custom_rfc_read_table_function_module @@ -52164,7 +52326,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SapOpenHubTable" # type: str + self.type: str = "SapOpenHubTable" self.open_hub_destination_name = open_hub_destination_name self.exclude_last_request = exclude_last_request self.base_request_id = base_request_id @@ -52366,7 +52528,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SapTable" # type: str + self.type: str = "SapTable" self.server = server self.system_number = system_number self.client_id = client_id @@ -52544,7 +52706,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SapTableResource" # type: str + self.type: str = "SapTableResource" self.table_name = table_name @@ -52714,7 +52876,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SapTableSource" # type: str + self.type: str = "SapTableSource" self.row_count = row_count self.row_skips = row_skips self.rfc_table_fields = rfc_table_fields @@ -52797,7 +52959,7 @@ def __init__( pipelines=pipelines, **kwargs ) - self.type = "ScheduleTrigger" # type: str + self.type: str = "ScheduleTrigger" self.recurrence = recurrence @@ -53019,7 +53181,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "Script" # type: str + self.type: str = "Script" self.script_block_execution_timeout = script_block_execution_timeout self.scripts = scripts self.log_settings = log_settings @@ -53200,7 +53362,7 @@ def __init__(self, *, value: str, **kwargs): :paramtype value: str """ super().__init__(**kwargs) - self.type = "SecureString" # type: str + self.type: str = "SecureString" self.value = value @@ -53246,7 +53408,7 @@ def __init__(self, *, offset: str, size: Optional[str] = None, **kwargs): :paramtype size: str """ super().__init__(**kwargs) - self.type = "SelfDependencyTumblingWindowTriggerReference" # type: str + self.type: str = "SelfDependencyTumblingWindowTriggerReference" self.offset = offset self.size = size @@ -53297,7 +53459,7 @@ def __init__( :paramtype linked_info: ~azure.mgmt.datafactory.models.LinkedIntegrationRuntimeType """ super().__init__(additional_properties=additional_properties, description=description, **kwargs) - self.type = "SelfHosted" # type: str + self.type: str = "SelfHosted" self.linked_info = linked_info @@ -53547,7 +53709,7 @@ def __init__( :paramtype links: list[~azure.mgmt.datafactory.models.LinkedIntegrationRuntime] """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "SelfHosted" # type: str + self.type: str = "SelfHosted" self.create_time = None self.task_queue_id = None self.internal_channel_encryption = None @@ -53714,7 +53876,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "ServiceNow" # type: str + self.type: str = "ServiceNow" self.endpoint = endpoint self.authentication_type = authentication_type self.username = username @@ -53825,7 +53987,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "ServiceNowObject" # type: str + self.type: str = "ServiceNowObject" self.table_name = table_name @@ -53927,7 +54089,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "ServiceNowSource" # type: str + self.type: str = "ServiceNowSource" self.query = query @@ -53996,7 +54158,7 @@ def __init__( super().__init__( additional_properties=additional_properties, description=description, annotations=annotations, **kwargs ) - self.type = "ServicePrincipal" # type: str + self.type: str = "ServicePrincipal" self.service_principal_id = service_principal_id self.service_principal_key = service_principal_key self.tenant = tenant @@ -54079,7 +54241,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "SetVariable" # type: str + self.type: str = "SetVariable" self.variable_name = variable_name self.value = value @@ -54135,7 +54297,7 @@ def __init__( super().__init__( additional_properties=additional_properties, folder_path=folder_path, file_name=file_name, **kwargs ) - self.type = "SftpLocation" # type: str + self.type: str = "SftpLocation" class SftpReadSettings(StoreReadSettings): # pylint: disable=too-many-instance-attributes @@ -54272,7 +54434,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SftpReadSettings" # type: str + self.type: str = "SftpReadSettings" self.recursive = recursive self.wildcard_folder_path = wildcard_folder_path self.wildcard_file_name = wildcard_file_name @@ -54446,7 +54608,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Sftp" # type: str + self.type: str = "Sftp" self.host = host self.port = port self.authentication_type = authentication_type @@ -54539,7 +54701,7 @@ def __init__( copy_behavior=copy_behavior, **kwargs ) - self.type = "SftpWriteSettings" # type: str + self.type: str = "SftpWriteSettings" self.operation_timeout = operation_timeout self.use_temp_file_rename = use_temp_file_rename @@ -54660,7 +54822,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SharePointOnlineList" # type: str + self.type: str = "SharePointOnlineList" self.site_url = site_url self.tenant_id = tenant_id self.service_principal_id = service_principal_id @@ -54768,7 +54930,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SharePointOnlineListResource" # type: str + self.type: str = "SharePointOnlineListResource" self.list_name = list_name @@ -54862,7 +55024,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SharePointOnlineListSource" # type: str + self.type: str = "SharePointOnlineListSource" self.query = query self.http_request_timeout = http_request_timeout @@ -54982,7 +55144,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Shopify" # type: str + self.type: str = "Shopify" self.host = host self.access_token = access_token self.use_encrypted_endpoints = use_encrypted_endpoints @@ -55089,7 +55251,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "ShopifyObject" # type: str + self.type: str = "ShopifyObject" self.table_name = table_name @@ -55191,7 +55353,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "ShopifySource" # type: str + self.type: str = "ShopifySource" self.query = query @@ -55306,7 +55468,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Smartsheet" # type: str + self.type: str = "Smartsheet" self.api_token = api_token self.encrypted_credential = encrypted_credential @@ -55419,7 +55581,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SnowflakeTable" # type: str + self.type: str = "SnowflakeTable" self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -55481,7 +55643,7 @@ def __init__( :paramtype additional_format_options: dict[str, JSON] """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "SnowflakeExportCopyCommand" # type: str + self.type: str = "SnowflakeExportCopyCommand" self.additional_copy_options = additional_copy_options self.additional_format_options = additional_format_options @@ -55543,7 +55705,7 @@ def __init__( :paramtype additional_format_options: dict[str, JSON] """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "SnowflakeImportCopyCommand" # type: str + self.type: str = "SnowflakeImportCopyCommand" self.additional_copy_options = additional_copy_options self.additional_format_options = additional_format_options @@ -55637,7 +55799,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Snowflake" # type: str + self.type: str = "Snowflake" self.connection_string = connection_string self.password = password self.encrypted_credential = encrypted_credential @@ -55747,7 +55909,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SnowflakeSink" # type: str + self.type: str = "SnowflakeSink" self.pre_copy_script = pre_copy_script self.import_settings = import_settings @@ -55776,12 +55938,13 @@ class SnowflakeSource(CopySource): :vartype disable_metrics_collection: JSON :ivar query: Snowflake Sql query. Type: string (or Expression with resultType string). :vartype query: JSON - :ivar export_settings: Snowflake export settings. + :ivar export_settings: Snowflake export settings. Required. :vartype export_settings: ~azure.mgmt.datafactory.models.SnowflakeExportCopyCommand """ _validation = { "type": {"required": True}, + "export_settings": {"required": True}, } _attribute_map = { @@ -55798,13 +55961,13 @@ class SnowflakeSource(CopySource): def __init__( self, *, + export_settings: "_models.SnowflakeExportCopyCommand", additional_properties: Optional[Dict[str, JSON]] = None, source_retry_count: Optional[JSON] = None, source_retry_wait: Optional[JSON] = None, max_concurrent_connections: Optional[JSON] = None, disable_metrics_collection: Optional[JSON] = None, query: Optional[JSON] = None, - export_settings: Optional["_models.SnowflakeExportCopyCommand"] = None, **kwargs ): """ @@ -55825,7 +55988,7 @@ def __init__( :paramtype disable_metrics_collection: JSON :keyword query: Snowflake Sql query. Type: string (or Expression with resultType string). :paramtype query: JSON - :keyword export_settings: Snowflake export settings. + :keyword export_settings: Snowflake export settings. Required. :paramtype export_settings: ~azure.mgmt.datafactory.models.SnowflakeExportCopyCommand """ super().__init__( @@ -55836,7 +55999,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SnowflakeSource" # type: str + self.type: str = "SnowflakeSource" self.query = query self.export_settings = export_settings @@ -56021,7 +56184,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Spark" # type: str + self.type: str = "Spark" self.host = host self.port = port self.server_type = server_type @@ -56153,7 +56316,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SparkObject" # type: str + self.type: str = "SparkObject" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -56257,7 +56420,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SparkSource" # type: str + self.type: str = "SparkSource" self.query = query @@ -56481,7 +56644,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SqlDWSink" # type: str + self.type: str = "SqlDWSink" self.pre_copy_script = pre_copy_script self.allow_poly_base = allow_poly_base self.poly_base_settings = poly_base_settings @@ -56625,7 +56788,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SqlDWSource" # type: str + self.type: str = "SqlDWSource" self.sql_reader_query = sql_reader_query self.sql_reader_stored_procedure_name = sql_reader_stored_procedure_name self.stored_procedure_parameters = stored_procedure_parameters @@ -56824,7 +56987,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SqlMISink" # type: str + self.type: str = "SqlMISink" self.sql_writer_stored_procedure_name = sql_writer_stored_procedure_name self.sql_writer_table_type = sql_writer_table_type self.pre_copy_script = pre_copy_script @@ -56971,7 +57134,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SqlMISource" # type: str + self.type: str = "SqlMISource" self.sql_reader_query = sql_reader_query self.sql_reader_stored_procedure_name = sql_reader_stored_procedure_name self.stored_procedure_parameters = stored_procedure_parameters @@ -57144,7 +57307,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "SqlServer" # type: str + self.type: str = "SqlServer" self.connection_string = connection_string self.user_name = user_name self.password = password @@ -57313,7 +57476,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SqlServerSink" # type: str + self.type: str = "SqlServerSink" self.sql_writer_stored_procedure_name = sql_writer_stored_procedure_name self.sql_writer_table_type = sql_writer_table_type self.pre_copy_script = pre_copy_script @@ -57460,7 +57623,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SqlServerSource" # type: str + self.type: str = "SqlServerSource" self.sql_reader_query = sql_reader_query self.sql_reader_stored_procedure_name = sql_reader_stored_procedure_name self.stored_procedure_parameters = stored_procedure_parameters @@ -57565,7 +57728,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "SqlServerStoredProcedure" # type: str + self.type: str = "SqlServerStoredProcedure" self.stored_procedure_name = stored_procedure_name self.stored_procedure_parameters = stored_procedure_parameters @@ -57686,7 +57849,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SqlServerTable" # type: str + self.type: str = "SqlServerTable" self.table_name = table_name self.schema_type_properties_schema = schema_type_properties_schema self.table = table @@ -57853,7 +58016,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "SqlSink" # type: str + self.type: str = "SqlSink" self.sql_writer_stored_procedure_name = sql_writer_stored_procedure_name self.sql_writer_table_type = sql_writer_table_type self.pre_copy_script = pre_copy_script @@ -58004,7 +58167,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SqlSource" # type: str + self.type: str = "SqlSource" self.sql_reader_query = sql_reader_query self.sql_reader_stored_procedure_name = sql_reader_stored_procedure_name self.stored_procedure_parameters = stored_procedure_parameters @@ -58192,7 +58355,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Square" # type: str + self.type: str = "Square" self.connection_properties = connection_properties self.host = host self.client_id = client_id @@ -58302,7 +58465,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SquareObject" # type: str + self.type: str = "SquareObject" self.table_name = table_name @@ -58404,7 +58567,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SquareSource" # type: str + self.type: str = "SquareSource" self.query = query @@ -58561,7 +58724,7 @@ def __init__( :paramtype description: str """ super().__init__(**kwargs) - self.type = None # type: Optional[str] + self.type: Optional[str] = None self.id = id self.name = name self.description = description @@ -58623,7 +58786,7 @@ def __init__( :paramtype variables: list[~azure.mgmt.datafactory.models.SsisVariable] """ super().__init__(id=id, name=name, description=description, **kwargs) - self.type = "Environment" # type: str + self.type: str = "Environment" self.folder_id = folder_id self.variables = variables @@ -58786,7 +58949,7 @@ def __init__( :paramtype description: str """ super().__init__(id=id, name=name, description=description, **kwargs) - self.type = "Folder" # type: str + self.type: str = "Folder" class SSISLogLocation(_serialization.Model): @@ -58990,7 +59153,7 @@ def __init__( :paramtype parameters: list[~azure.mgmt.datafactory.models.SsisParameter] """ super().__init__(id=id, name=name, description=description, **kwargs) - self.type = "Package" # type: str + self.type: str = "Package" self.folder_id = folder_id self.project_version = project_version self.project_id = project_id @@ -59265,7 +59428,7 @@ def __init__( :paramtype parameters: list[~azure.mgmt.datafactory.models.SsisParameter] """ super().__init__(id=id, name=name, description=description, **kwargs) - self.type = "Project" # type: str + self.type: str = "Project" self.folder_id = folder_id self.version = version self.environment_refs = environment_refs @@ -59561,7 +59724,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "Switch" # type: str + self.type: str = "Switch" self.on = on self.cases = cases self.default_activities = default_activities @@ -59714,7 +59877,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Sybase" # type: str + self.type: str = "Sybase" self.server = server self.database = database self.schema = schema @@ -59820,7 +59983,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "SybaseSource" # type: str + self.type: str = "SybaseSource" self.query = query @@ -59923,7 +60086,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "SybaseTable" # type: str + self.type: str = "SybaseTable" self.table_name = table_name @@ -60064,7 +60227,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "SynapseNotebook" # type: str + self.type: str = "SynapseNotebook" self.notebook = notebook self.spark_pool = spark_pool self.parameters = parameters @@ -60299,7 +60462,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "SparkJob" # type: str + self.type: str = "SparkJob" self.spark_job = spark_job self.arguments = arguments self.file = file @@ -60446,7 +60609,7 @@ def __init__( :paramtype type_conversion_settings: ~azure.mgmt.datafactory.models.TypeConversionSettings """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "TabularTranslator" # type: str + self.type: str = "TabularTranslator" self.column_mappings = column_mappings self.schema_mapping = schema_mapping self.collection_reference = collection_reference @@ -60497,7 +60660,7 @@ def __init__( :paramtype preserve_compression_file_name_as_folder: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "TarGZipReadSettings" # type: str + self.type: str = "TarGZipReadSettings" self.preserve_compression_file_name_as_folder = preserve_compression_file_name_as_folder @@ -60542,7 +60705,7 @@ def __init__( :paramtype preserve_compression_file_name_as_folder: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "TarReadSettings" # type: str + self.type: str = "TarReadSettings" self.preserve_compression_file_name_as_folder = preserve_compression_file_name_as_folder @@ -60659,7 +60822,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "TeamDesk" # type: str + self.type: str = "TeamDesk" self.authentication_type = authentication_type self.url = url self.user_name = user_name @@ -60780,7 +60943,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Teradata" # type: str + self.type: str = "Teradata" self.connection_string = connection_string self.server = server self.authentication_type = authentication_type @@ -60949,7 +61112,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "TeradataSource" # type: str + self.type: str = "TeradataSource" self.query = query self.partition_option = partition_option self.partition_settings = partition_settings @@ -61062,7 +61225,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "TeradataTable" # type: str + self.type: str = "TeradataTable" self.database = database self.table = table @@ -61188,7 +61351,7 @@ def __init__( super().__init__( additional_properties=additional_properties, serializer=serializer, deserializer=deserializer, **kwargs ) - self.type = "TextFormat" # type: str + self.type: str = "TextFormat" self.column_delimiter = column_delimiter self.row_delimiter = row_delimiter self.escape_char = escape_char @@ -61232,7 +61395,7 @@ def __init__(self, *, reference_trigger: "_models.TriggerReference", **kwargs): :paramtype reference_trigger: ~azure.mgmt.datafactory.models.TriggerReference """ super().__init__(**kwargs) - self.type = "TriggerDependencyReference" # type: str + self.type: str = "TriggerDependencyReference" self.reference_trigger = reference_trigger @@ -61715,7 +61878,7 @@ def __init__( super().__init__( additional_properties=additional_properties, description=description, annotations=annotations, **kwargs ) - self.type = "TumblingWindowTrigger" # type: str + self.type: str = "TumblingWindowTrigger" self.pipeline = pipeline self.frequency = frequency self.interval = interval @@ -61781,7 +61944,7 @@ def __init__( :paramtype size: str """ super().__init__(reference_trigger=reference_trigger, **kwargs) - self.type = "TumblingWindowTriggerDependencyReference" # type: str + self.type: str = "TumblingWindowTriggerDependencyReference" self.offset = offset self.size = size @@ -61864,7 +62027,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Twilio" # type: str + self.type: str = "Twilio" self.user_name = user_name self.password = password @@ -62036,7 +62199,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "Until" # type: str + self.type: str = "Until" self.expression = expression self.timeout = timeout self.activities = activities @@ -62311,7 +62474,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "Validation" # type: str + self.type: str = "Validation" self.timeout = timeout self.sleep = sleep self.minimum_size = minimum_size @@ -62439,7 +62602,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Vertica" # type: str + self.type: str = "Vertica" self.connection_string = connection_string self.pwd = pwd self.encrypted_credential = encrypted_credential @@ -62543,7 +62706,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "VerticaSource" # type: str + self.type: str = "VerticaSource" self.query = query @@ -62663,7 +62826,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "VerticaTable" # type: str + self.type: str = "VerticaTable" self.table_name = table_name self.table = table self.schema_type_properties_schema = schema_type_properties_schema @@ -62741,7 +62904,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "Wait" # type: str + self.type: str = "Wait" self.wait_time_in_seconds = wait_time_in_seconds @@ -62890,7 +63053,7 @@ def __init__( policy=policy, **kwargs ) - self.type = "WebActivity" # type: str + self.type: str = "WebActivity" self.method = method self.url = url self.headers = headers @@ -63020,7 +63183,7 @@ def __init__(self, *, url: JSON, **kwargs): """ super().__init__(**kwargs) self.url = url - self.authentication_type = None # type: Optional[str] + self.authentication_type: Optional[str] = None class WebAnonymousAuthentication(WebLinkedServiceTypeProperties): @@ -63053,7 +63216,7 @@ def __init__(self, *, url: JSON, **kwargs): :paramtype url: JSON """ super().__init__(url=url, **kwargs) - self.authentication_type = "Anonymous" # type: str + self.authentication_type: str = "Anonymous" class WebBasicAuthentication(WebLinkedServiceTypeProperties): @@ -63100,7 +63263,7 @@ def __init__(self, *, url: JSON, username: JSON, password: "_models.SecretBase", :paramtype password: ~azure.mgmt.datafactory.models.SecretBase """ super().__init__(url=url, **kwargs) - self.authentication_type = "Basic" # type: str + self.authentication_type: str = "Basic" self.username = username self.password = password @@ -63147,7 +63310,7 @@ def __init__(self, *, url: JSON, pfx: "_models.SecretBase", password: "_models.S :paramtype password: ~azure.mgmt.datafactory.models.SecretBase """ super().__init__(url=url, **kwargs) - self.authentication_type = "ClientCertificate" # type: str + self.authentication_type: str = "ClientCertificate" self.pfx = pfx self.password = password @@ -63279,7 +63442,7 @@ def __init__( user_properties=user_properties, **kwargs ) - self.type = "WebHook" # type: str + self.type: str = "WebHook" self.method = method self.url = url self.timeout = timeout @@ -63360,7 +63523,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Web" # type: str + self.type: str = "Web" self.type_properties = type_properties @@ -63444,7 +63607,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "WebSource" # type: str + self.type: str = "WebSource" self.additional_columns = additional_columns @@ -63557,7 +63720,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "WebTable" # type: str + self.type: str = "WebTable" self.index = index self.path = path @@ -63625,7 +63788,7 @@ def __init__( :paramtype document_locale: str """ super().__init__(description=description, annotations=annotations, folder=folder, **kwargs) - self.type = "WranglingDataFlow" # type: str + self.type: str = "WranglingDataFlow" self.sources = sources self.script = script self.document_locale = document_locale @@ -63762,7 +63925,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Xero" # type: str + self.type: str = "Xero" self.connection_properties = connection_properties self.host = host self.consumer_key = consumer_key @@ -63871,7 +64034,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "XeroObject" # type: str + self.type: str = "XeroObject" self.table_name = table_name @@ -63973,7 +64136,7 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "XeroSource" # type: str + self.type: str = "XeroSource" self.query = query @@ -64102,7 +64265,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "Xml" # type: str + self.type: str = "Xml" self.location = location self.encoding_name = encoding_name self.null_value = null_value @@ -64184,7 +64347,7 @@ def __init__( :paramtype namespace_prefixes: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "XmlReadSettings" # type: str + self.type: str = "XmlReadSettings" self.compression_properties = compression_properties self.validation_mode = validation_mode self.detect_data_type = detect_data_type @@ -64284,7 +64447,7 @@ def __init__( disable_metrics_collection=disable_metrics_collection, **kwargs ) - self.type = "XmlSource" # type: str + self.type: str = "XmlSource" self.store_settings = store_settings self.format_settings = format_settings self.additional_columns = additional_columns @@ -64402,7 +64565,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Zendesk" # type: str + self.type: str = "Zendesk" self.authentication_type = authentication_type self.url = url self.user_name = user_name @@ -64452,7 +64615,7 @@ def __init__( :paramtype preserve_zip_file_name_as_folder: JSON """ super().__init__(additional_properties=additional_properties, **kwargs) - self.type = "ZipDeflateReadSettings" # type: str + self.type: str = "ZipDeflateReadSettings" self.preserve_zip_file_name_as_folder = preserve_zip_file_name_as_folder @@ -64576,7 +64739,7 @@ def __init__( annotations=annotations, **kwargs ) - self.type = "Zoho" # type: str + self.type: str = "Zoho" self.connection_properties = connection_properties self.endpoint = endpoint self.access_token = access_token @@ -64684,7 +64847,7 @@ def __init__( folder=folder, **kwargs ) - self.type = "ZohoObject" # type: str + self.type: str = "ZohoObject" self.table_name = table_name @@ -64786,5 +64949,5 @@ def __init__( additional_columns=additional_columns, **kwargs ) - self.type = "ZohoSource" # type: str + self.type: str = "ZohoSource" self.query = query diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/__init__.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/__init__.py index a20c42cd8bfb..b4c9fa93e0a9 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/__init__.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/__init__.py @@ -23,13 +23,14 @@ from ._data_flow_debug_session_operations import DataFlowDebugSessionOperations from ._managed_virtual_networks_operations import ManagedVirtualNetworksOperations from ._managed_private_endpoints_operations import ManagedPrivateEndpointsOperations +from ._credential_operations_operations import CredentialOperationsOperations from ._private_end_point_connections_operations import PrivateEndPointConnectionsOperations from ._private_endpoint_connection_operations import PrivateEndpointConnectionOperations from ._private_link_resources_operations import PrivateLinkResourcesOperations from ._global_parameters_operations import GlobalParametersOperations from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import * # pylint: disable=unused-wildcard-import from ._patch import patch_sdk as _patch_sdk __all__ = [ @@ -50,6 +51,7 @@ "DataFlowDebugSessionOperations", "ManagedVirtualNetworksOperations", "ManagedPrivateEndpointsOperations", + "CredentialOperationsOperations", "PrivateEndPointConnectionsOperations", "PrivateEndpointConnectionOperations", "PrivateLinkResourcesOperations", diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_activity_runs_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_activity_runs_operations.py index 4403d3addcf0..1bff32104c8f 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_activity_runs_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_activity_runs_operations.py @@ -45,8 +45,8 @@ def build_query_by_pipeline_run_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -70,7 +70,7 @@ def build_query_by_pipeline_run_request( "runId": _SERIALIZER.url("run_id", run_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -201,11 +201,11 @@ def query_by_pipeline_run( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ActivityRunsQueryResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ActivityRunsQueryResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -229,9 +229,9 @@ def query_by_pipeline_run( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -248,4 +248,6 @@ def query_by_pipeline_run( return deserialized - query_by_pipeline_run.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}/queryActivityruns"} # type: ignore + query_by_pipeline_run.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}/queryActivityruns" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_credential_operations_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_credential_operations_operations.py new file mode 100644 index 000000000000..0cef0dbfe674 --- /dev/null +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_credential_operations_operations.py @@ -0,0 +1,662 @@ +# 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. +# -------------------------------------------------------------------------- +import sys +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload +import urllib.parse + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + 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 _convert_request, _format_url_section + +if sys.version_info >= (3, 8): + from typing import Literal # pylint: disable=no-name-in-module, ungrouped-imports +else: + from typing_extensions import Literal # type: ignore # pylint: disable=ungrouped-imports +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_factory_request( + resource_group_name: str, factory_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: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials", + ) # 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\._\(\)]+$" + ), + "factoryName": _SERIALIZER.url( + "factory_name", + factory_name, + "str", + max_length=63, + min_length=3, + pattern=r"^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$", + ), + } + + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + + # 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, + factory_name: str, + credential_name: str, + subscription_id: str, + *, + if_match: Optional[str] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}", + ) # 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\._\(\)]+$" + ), + "factoryName": _SERIALIZER.url( + "factory_name", + factory_name, + "str", + max_length=63, + min_length=3, + pattern=r"^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$", + ), + "credentialName": _SERIALIZER.url( + "credential_name", + credential_name, + "str", + max_length=127, + min_length=1, + pattern=r"^([_A-Za-z0-9]|([_A-Za-z0-9][-_A-Za-z0-9]{0,125}[_A-Za-z0-9]))$", + ), + } + + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if if_match is not None: + _headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str") + 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_get_request( + resource_group_name: str, + factory_name: str, + credential_name: str, + subscription_id: str, + *, + if_none_match: Optional[str] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}", + ) # 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\._\(\)]+$" + ), + "factoryName": _SERIALIZER.url( + "factory_name", + factory_name, + "str", + max_length=63, + min_length=3, + pattern=r"^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$", + ), + "credentialName": _SERIALIZER.url( + "credential_name", + credential_name, + "str", + max_length=127, + min_length=1, + pattern=r"^([_A-Za-z0-9]|([_A-Za-z0-9][-_A-Za-z0-9]{0,125}[_A-Za-z0-9]))$", + ), + } + + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if if_none_match is not None: + _headers["If-None-Match"] = _SERIALIZER.header("if_none_match", if_none_match, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_delete_request( + resource_group_name: str, factory_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: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop( + "template_url", + "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}", + ) # 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\._\(\)]+$" + ), + "factoryName": _SERIALIZER.url( + "factory_name", + factory_name, + "str", + max_length=63, + min_length=3, + pattern=r"^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$", + ), + "credentialName": _SERIALIZER.url( + "credential_name", + credential_name, + "str", + max_length=127, + min_length=1, + pattern=r"^([_A-Za-z0-9]|([_A-Za-z0-9][-_A-Za-z0-9]{0,125}[_A-Za-z0-9]))$", + ), + } + + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore + + # 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) + + +class CredentialOperationsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.datafactory.DataFactoryManagementClient`'s + :attr:`credential_operations` 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_factory( + self, resource_group_name: str, factory_name: str, **kwargs: Any + ) -> Iterable["_models.ManagedIdentityCredentialResource"]: + """List credentials. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: An iterator like instance of either ManagedIdentityCredentialResource or the result of + cls(response) + :rtype: + ~azure.core.paging.ItemPaged[~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: Literal["2018-06-01"] = kwargs.pop( + "api_version", _params.pop("api-version", self._config.api_version) + ) + cls: ClsType[_models.CredentialListResponse] = kwargs.pop("cls", None) + + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + def prepare_request(next_link=None): + if not next_link: + + request = build_list_by_factory_request( + resource_group_name=resource_group_name, + factory_name=factory_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + template_url=self.list_by_factory.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) + + else: + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) + request.method = "GET" + return request + + def extract_data(pipeline_response): + deserialized = self._deserialize("CredentialListResponse", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) # type: ignore + return deserialized.next_link or None, iter(list_of_elem) + + def get_next(next_link=None): + request = prepare_request(next_link) + + pipeline_response: PipelineResponse = self._client._pipeline.run( # 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) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials" + } + + @overload + def create_or_update( + self, + resource_group_name: str, + factory_name: str, + credential_name: str, + credential: _models.ManagedIdentityCredentialResource, + if_match: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ManagedIdentityCredentialResource: + """Creates or updates a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_name: str + :param credential: Credential resource definition. Required. + :type credential: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource + :param if_match: ETag of the credential entity. Should only be specified for update, for which + it should match existing entity or can be * for unconditional update. Default value is None. + :type if_match: 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: ManagedIdentityCredentialResource or the result of cls(response) + :rtype: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_or_update( + self, + resource_group_name: str, + factory_name: str, + credential_name: str, + credential: IO, + if_match: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.ManagedIdentityCredentialResource: + """Creates or updates a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_name: str + :param credential: Credential resource definition. Required. + :type credential: IO + :param if_match: ETag of the credential entity. Should only be specified for update, for which + it should match existing entity or can be * for unconditional update. Default value is None. + :type if_match: 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: ManagedIdentityCredentialResource or the result of cls(response) + :rtype: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_or_update( + self, + resource_group_name: str, + factory_name: str, + credential_name: str, + credential: Union[_models.ManagedIdentityCredentialResource, IO], + if_match: Optional[str] = None, + **kwargs: Any + ) -> _models.ManagedIdentityCredentialResource: + """Creates or updates a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_name: str + :param credential: Credential resource definition. Is either a model type or a IO type. + Required. + :type credential: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource or IO + :param if_match: ETag of the credential entity. Should only be specified for update, for which + it should match existing entity or can be * for unconditional update. Default value is None. + :type if_match: 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: ManagedIdentityCredentialResource or the result of cls(response) + :rtype: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + 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: Literal["2018-06-01"] = kwargs.pop( + "api_version", _params.pop("api-version", self._config.api_version) + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ManagedIdentityCredentialResource] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(credential, (IO, bytes)): + _content = credential + else: + _json = self._serialize.body(credential, "ManagedIdentityCredentialResource") + + request = build_create_or_update_request( + resource_group_name=resource_group_name, + factory_name=factory_name, + credential_name=credential_name, + subscription_id=self._config.subscription_id, + if_match=if_match, + 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) + + pipeline_response: PipelineResponse = self._client._pipeline.run( # 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) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + deserialized = self._deserialize("ManagedIdentityCredentialResource", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}" + } + + @distributed_trace + def get( + self, + resource_group_name: str, + factory_name: str, + credential_name: str, + if_none_match: Optional[str] = None, + **kwargs: Any + ) -> Optional[_models.ManagedIdentityCredentialResource]: + """Gets a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_name: str + :param if_none_match: ETag of the credential entity. Should only be specified for get. If the + ETag matches the existing entity tag, or if * was provided, then no content will be returned. + Default value is None. + :type if_none_match: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: ManagedIdentityCredentialResource or None or the result of cls(response) + :rtype: ~azure.mgmt.datafactory.models.ManagedIdentityCredentialResource or None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: Literal["2018-06-01"] = kwargs.pop( + "api_version", _params.pop("api-version", self._config.api_version) + ) + cls: ClsType[Optional[_models.ManagedIdentityCredentialResource]] = kwargs.pop("cls", None) + + request = build_get_request( + resource_group_name=resource_group_name, + factory_name=factory_name, + credential_name=credential_name, + subscription_id=self._config.subscription_id, + if_none_match=if_none_match, + 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) + + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + request, stream=False, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 304]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize("ManagedIdentityCredentialResource", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}" + } + + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, resource_group_name: str, factory_name: str, credential_name: str, **kwargs: Any + ) -> None: + """Deletes a credential. + + :param resource_group_name: The resource group name. Required. + :type resource_group_name: str + :param factory_name: The factory name. Required. + :type factory_name: str + :param credential_name: Credential name. Required. + :type credential_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, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: Literal["2018-06-01"] = kwargs.pop( + "api_version", _params.pop("api-version", self._config.api_version) + ) + cls: ClsType[None] = kwargs.pop("cls", None) + + request = build_delete_request( + resource_group_name=resource_group_name, + factory_name=factory_name, + credential_name=credential_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) + + pipeline_response: PipelineResponse = self._client._pipeline.run( # 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) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + if cls: + return cls(pipeline_response, None, {}) + + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/credentials/{credentialName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_data_flow_debug_session_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_data_flow_debug_session_operations.py index 4e942bbc4eca..ce588f4b7821 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_data_flow_debug_session_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_data_flow_debug_session_operations.py @@ -49,8 +49,8 @@ def build_create_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -73,7 +73,7 @@ def build_create_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -92,7 +92,7 @@ def build_query_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -115,7 +115,7 @@ def build_query_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -132,8 +132,8 @@ def build_add_data_flow_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -156,7 +156,7 @@ def build_add_data_flow_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -175,8 +175,8 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -199,7 +199,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -218,8 +218,8 @@ def build_execute_command_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -242,7 +242,7 @@ def build_execute_command_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -292,11 +292,11 @@ def _create_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.CreateDataFlowDebugSessionResponse]] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Optional[_models.CreateDataFlowDebugSessionResponse]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -319,9 +319,9 @@ def _create_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -344,7 +344,9 @@ def _create_initial( return deserialized - _create_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession"} # type: ignore + _create_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession" + } @overload def begin_create( @@ -455,16 +457,16 @@ def begin_create( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.CreateDataFlowDebugSessionResponse] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.CreateDataFlowDebugSessionResponse] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = self._create_initial( # type: ignore + raw_result = self._create_initial( resource_group_name=resource_group_name, factory_name=factory_name, request=request, @@ -484,7 +486,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -496,9 +498,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_create.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession"} # type: ignore + begin_create.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession" + } @distributed_trace def query_by_factory( @@ -519,10 +523,10 @@ def query_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.QueryDataFlowDebugSessionsResponse] + ) + cls: ClsType[_models.QueryDataFlowDebugSessionsResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -545,7 +549,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -561,7 +565,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -569,13 +573,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("QueryDataFlowDebugSessionsResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -588,7 +592,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - query_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryDataFlowDebugSessions"} # type: ignore + query_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryDataFlowDebugSessions" + } @overload def add_data_flow( @@ -680,11 +686,11 @@ def add_data_flow( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.AddDataFlowToDebugSessionResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.AddDataFlowToDebugSessionResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -707,9 +713,9 @@ def add_data_flow( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -726,7 +732,9 @@ def add_data_flow( return deserialized - add_data_flow.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/addDataFlowToDebugSession"} # type: ignore + add_data_flow.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/addDataFlowToDebugSession" + } @overload def delete( # pylint: disable=inconsistent-return-statements @@ -818,11 +826,11 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[None] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -845,9 +853,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -860,7 +868,9 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/deleteDataFlowDebugSession"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/deleteDataFlowDebugSession" + } def _execute_command_initial( self, @@ -880,11 +890,11 @@ def _execute_command_initial( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.DataFlowDebugCommandResponse]] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Optional[_models.DataFlowDebugCommandResponse]] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -907,9 +917,9 @@ def _execute_command_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -932,7 +942,9 @@ def _execute_command_initial( return deserialized - _execute_command_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/executeDataFlowDebugCommand"} # type: ignore + _execute_command_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/executeDataFlowDebugCommand" + } @overload def begin_execute_command( @@ -1043,16 +1055,16 @@ def begin_execute_command( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DataFlowDebugCommandResponse] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.DataFlowDebugCommandResponse] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = self._execute_command_initial( # type: ignore + raw_result = self._execute_command_initial( resource_group_name=resource_group_name, factory_name=factory_name, request=request, @@ -1072,7 +1084,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -1084,6 +1096,8 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_execute_command.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/executeDataFlowDebugCommand"} # type: ignore + begin_execute_command.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/executeDataFlowDebugCommand" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_data_flows_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_data_flows_operations.py index f9ad715cb3a7..9e6d107128e6 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_data_flows_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_data_flows_operations.py @@ -53,8 +53,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -85,7 +85,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -112,7 +112,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -143,7 +143,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -162,7 +162,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -193,7 +193,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -210,7 +210,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -233,7 +233,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -373,11 +373,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DataFlowResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.DataFlowResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -402,9 +402,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -421,7 +421,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}" + } @distributed_trace def get( @@ -460,10 +462,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DataFlowResource] + ) + cls: ClsType[_models.DataFlowResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -477,9 +479,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -496,7 +498,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -526,10 +530,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -542,9 +546,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -557,7 +561,9 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows/{dataFlowName}" + } @distributed_trace def list_by_factory( @@ -577,10 +583,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DataFlowListResponse] + ) + cls: ClsType[_models.DataFlowListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -603,7 +609,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -619,7 +625,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -627,13 +633,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("DataFlowListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -646,4 +652,6 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/dataflows" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_datasets_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_datasets_operations.py index d054f778cceb..5662f1375424 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_datasets_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_datasets_operations.py @@ -47,7 +47,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -70,7 +70,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -93,8 +93,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -125,7 +125,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -152,7 +152,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -183,7 +183,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -202,7 +202,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -233,7 +233,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -281,10 +281,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DatasetListResponse] + ) + cls: ClsType[_models.DatasetListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -307,7 +307,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -323,7 +323,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -331,13 +331,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("DatasetListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -350,7 +350,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets" + } @overload def create_or_update( @@ -462,11 +464,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.DatasetResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.DatasetResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -491,9 +493,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -510,7 +512,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}" + } @distributed_trace def get( @@ -549,10 +553,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.DatasetResource]] + ) + cls: ClsType[Optional[_models.DatasetResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -566,9 +570,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -587,7 +591,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -617,10 +623,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -633,9 +639,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -648,4 +654,6 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/datasets/{datasetName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_exposure_control_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_exposure_control_operations.py index a7dcc1c9ab46..134e3d60b53d 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_exposure_control_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_exposure_control_operations.py @@ -43,8 +43,8 @@ def build_get_feature_value_request(location_id: str, subscription_id: str, **kw _headers = case_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -57,7 +57,7 @@ def build_get_feature_value_request(location_id: str, subscription_id: str, **kw "locationId": _SERIALIZER.url("location_id", location_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -76,8 +76,8 @@ def build_get_feature_value_by_factory_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -100,7 +100,7 @@ def build_get_feature_value_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -119,8 +119,8 @@ def build_query_feature_values_by_factory_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -143,7 +143,7 @@ def build_query_feature_values_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -248,11 +248,11 @@ def get_feature_value( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ExposureControlResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ExposureControlResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -274,9 +274,9 @@ def get_feature_value( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -293,7 +293,9 @@ def get_feature_value( return deserialized - get_feature_value.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/getFeatureValue"} # type: ignore + get_feature_value.metadata = { + "url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/getFeatureValue" + } @overload def get_feature_value_by_factory( @@ -385,11 +387,11 @@ def get_feature_value_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ExposureControlResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ExposureControlResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -412,9 +414,9 @@ def get_feature_value_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -431,7 +433,9 @@ def get_feature_value_by_factory( return deserialized - get_feature_value_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getFeatureValue"} # type: ignore + get_feature_value_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getFeatureValue" + } @overload def query_feature_values_by_factory( @@ -527,11 +531,11 @@ def query_feature_values_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ExposureControlBatchResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ExposureControlBatchResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -554,9 +558,9 @@ def query_feature_values_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -573,4 +577,6 @@ def query_feature_values_by_factory( return deserialized - query_feature_values_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryFeaturesValue"} # type: ignore + query_feature_values_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryFeaturesValue" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_factories_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_factories_operations.py index 7c26762cf305..d6d830cbcfa4 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_factories_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_factories_operations.py @@ -45,7 +45,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -54,7 +54,7 @@ def build_list_request(subscription_id: str, **kwargs: Any) -> HttpRequest: "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -69,8 +69,8 @@ def build_configure_factory_repo_request(location_id: str, subscription_id: str, _headers = case_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -83,7 +83,7 @@ def build_configure_factory_repo_request(location_id: str, subscription_id: str, "locationId": _SERIALIZER.url("location_id", location_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -100,7 +100,7 @@ def build_list_by_resource_group_request(resource_group_name: str, subscription_ _headers = case_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -115,7 +115,7 @@ def build_list_by_resource_group_request(resource_group_name: str, subscription_ ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -132,8 +132,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -156,7 +156,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -177,8 +177,8 @@ def build_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -201,7 +201,7 @@ def build_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -225,7 +225,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -248,7 +248,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -267,7 +267,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -290,7 +290,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -307,8 +307,8 @@ def build_get_git_hub_access_token_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -331,7 +331,7 @@ def build_get_git_hub_access_token_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -350,8 +350,8 @@ def build_get_data_plane_access_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -374,7 +374,7 @@ def build_get_data_plane_access_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -418,10 +418,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.Factory"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.FactoryListResponse] + ) + cls: ClsType[_models.FactoryListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -442,7 +442,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -458,7 +458,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -466,13 +466,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("FactoryListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -485,7 +485,7 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/factories"} # type: ignore + list.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/factories"} @overload def configure_factory_repo( @@ -560,11 +560,11 @@ def configure_factory_repo( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Factory] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Factory] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -586,9 +586,9 @@ def configure_factory_repo( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -605,7 +605,9 @@ def configure_factory_repo( return deserialized - configure_factory_repo.metadata = {"url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/configureFactoryRepo"} # type: ignore + configure_factory_repo.metadata = { + "url": "/subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/configureFactoryRepo" + } @distributed_trace def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Iterable["_models.Factory"]: @@ -621,10 +623,10 @@ def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> Ite _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.FactoryListResponse] + ) + cls: ClsType[_models.FactoryListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -646,7 +648,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -662,7 +664,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -670,13 +672,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("FactoryListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -689,7 +691,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_resource_group.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories"} # type: ignore + list_by_resource_group.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories" + } @overload def create_or_update( @@ -792,11 +796,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Factory] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Factory] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -820,9 +824,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -839,7 +843,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}" + } @overload def update( @@ -931,11 +937,11 @@ def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.Factory] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.Factory] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -958,9 +964,9 @@ def update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -977,7 +983,9 @@ def update( return deserialized - update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}"} # type: ignore + update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}" + } @distributed_trace def get( @@ -1009,10 +1017,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.Factory]] + ) + cls: ClsType[Optional[_models.Factory]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -1025,9 +1033,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1046,7 +1054,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -1074,10 +1084,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -1089,9 +1099,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1104,7 +1114,9 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}" + } @overload def get_git_hub_access_token( @@ -1197,11 +1209,11 @@ def get_git_hub_access_token( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.GitHubAccessTokenResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.GitHubAccessTokenResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -1224,9 +1236,9 @@ def get_git_hub_access_token( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1243,7 +1255,9 @@ def get_git_hub_access_token( return deserialized - get_git_hub_access_token.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getGitHubAccessToken"} # type: ignore + get_git_hub_access_token.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getGitHubAccessToken" + } @overload def get_data_plane_access( @@ -1331,11 +1345,11 @@ def get_data_plane_access( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.AccessPolicyResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.AccessPolicyResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -1358,9 +1372,9 @@ def get_data_plane_access( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1377,4 +1391,6 @@ def get_data_plane_access( return deserialized - get_data_plane_access.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getDataPlaneAccess"} # type: ignore + get_data_plane_access.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/getDataPlaneAccess" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_global_parameters_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_global_parameters_operations.py index a654ebf5d529..66303ddae0ea 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_global_parameters_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_global_parameters_operations.py @@ -47,7 +47,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -70,7 +70,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -87,7 +87,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -118,7 +118,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -135,8 +135,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -167,7 +167,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -186,7 +186,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -217,7 +217,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -266,10 +266,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.GlobalParameterListResponse] + ) + cls: ClsType[_models.GlobalParameterListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -292,7 +292,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -308,7 +308,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -316,13 +316,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("GlobalParameterListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -335,7 +335,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters" + } @distributed_trace def get( @@ -365,10 +367,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.GlobalParameterResource] + ) + cls: ClsType[_models.GlobalParameterResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -381,9 +383,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -400,7 +402,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}" + } @overload def create_or_update( @@ -501,11 +505,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.GlobalParameterResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.GlobalParameterResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -529,9 +533,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -548,7 +552,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -578,10 +584,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -594,9 +600,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -609,4 +615,6 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/globalParameters/{globalParameterName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtime_nodes_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtime_nodes_operations.py index 5319e7fc7830..8ad2c8973fc0 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtime_nodes_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtime_nodes_operations.py @@ -50,7 +50,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -84,7 +84,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -106,7 +106,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -140,7 +140,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -162,8 +162,8 @@ def build_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -197,7 +197,7 @@ def build_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -221,7 +221,7 @@ def build_get_ip_address_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -255,7 +255,7 @@ def build_get_ip_address_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -315,10 +315,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SelfHostedIntegrationRuntimeNode] + ) + cls: ClsType[_models.SelfHostedIntegrationRuntimeNode] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -332,9 +332,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -351,7 +351,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -383,10 +385,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -400,9 +402,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -415,7 +417,9 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}" + } @overload def update( @@ -529,11 +533,11 @@ def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SelfHostedIntegrationRuntimeNode] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SelfHostedIntegrationRuntimeNode] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -558,9 +562,9 @@ def update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -577,7 +581,9 @@ def update( return deserialized - update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}"} # type: ignore + update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}" + } @distributed_trace def get_ip_address( @@ -609,10 +615,10 @@ def get_ip_address( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeNodeIpAddress] + ) + cls: ClsType[_models.IntegrationRuntimeNodeIpAddress] = kwargs.pop("cls", None) request = build_get_ip_address_request( resource_group_name=resource_group_name, @@ -626,9 +632,9 @@ def get_ip_address( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -645,4 +651,6 @@ def get_ip_address( return deserialized - get_ip_address.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}/ipAddress"} # type: ignore + get_ip_address.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/nodes/{nodeName}/ipAddress" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtime_object_metadata_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtime_object_metadata_operations.py index 55096ecf0375..790bf3c6cd99 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtime_object_metadata_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtime_object_metadata_operations.py @@ -47,7 +47,7 @@ def build_refresh_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -78,7 +78,7 @@ def build_refresh_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -95,8 +95,8 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -127,7 +127,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -173,10 +173,10 @@ def _refresh_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.SsisObjectMetadataStatusResponse]] + ) + cls: ClsType[Optional[_models.SsisObjectMetadataStatusResponse]] = kwargs.pop("cls", None) request = build_refresh_request( resource_group_name=resource_group_name, @@ -189,9 +189,9 @@ def _refresh_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -210,7 +210,9 @@ def _refresh_initial( return deserialized - _refresh_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/refreshObjectMetadata"} # type: ignore + _refresh_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/refreshObjectMetadata" + } @distributed_trace def begin_refresh( @@ -241,15 +243,15 @@ def begin_refresh( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SsisObjectMetadataStatusResponse] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + cls: ClsType[_models.SsisObjectMetadataStatusResponse] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = self._refresh_initial( # type: ignore + raw_result = self._refresh_initial( resource_group_name=resource_group_name, factory_name=factory_name, integration_runtime_name=integration_runtime_name, @@ -268,7 +270,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -280,9 +282,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_refresh.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/refreshObjectMetadata"} # type: ignore + begin_refresh.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/refreshObjectMetadata" + } @overload def get( @@ -388,11 +392,11 @@ def get( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SsisObjectMetadataListResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.SsisObjectMetadataListResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -419,9 +423,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -438,4 +442,6 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getObjectMetadata"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getObjectMetadata" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtimes_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtimes_operations.py index f32260633730..2712120e22b7 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtimes_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_integration_runtimes_operations.py @@ -49,7 +49,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -72,7 +72,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -95,8 +95,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -127,7 +127,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -154,7 +154,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -185,7 +185,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -204,8 +204,8 @@ def build_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -236,7 +236,7 @@ def build_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -255,7 +255,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -286,7 +286,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -303,7 +303,7 @@ def build_get_status_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -334,7 +334,7 @@ def build_get_status_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -351,7 +351,7 @@ def build_list_outbound_network_dependencies_endpoints_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -382,7 +382,7 @@ def build_list_outbound_network_dependencies_endpoints_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -399,7 +399,7 @@ def build_get_connection_info_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -430,7 +430,7 @@ def build_get_connection_info_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -447,8 +447,8 @@ def build_regenerate_auth_key_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -479,7 +479,7 @@ def build_regenerate_auth_key_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -498,7 +498,7 @@ def build_list_auth_keys_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -529,7 +529,7 @@ def build_list_auth_keys_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -546,7 +546,7 @@ def build_start_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -577,7 +577,7 @@ def build_start_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -594,7 +594,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -625,7 +625,7 @@ def build_stop_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -642,7 +642,7 @@ def build_sync_credentials_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -673,7 +673,7 @@ def build_sync_credentials_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -690,7 +690,7 @@ def build_get_monitoring_data_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -721,7 +721,7 @@ def build_get_monitoring_data_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -738,7 +738,7 @@ def build_upgrade_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -769,7 +769,7 @@ def build_upgrade_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -786,8 +786,8 @@ def build_remove_links_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -818,7 +818,7 @@ def build_remove_links_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -837,8 +837,8 @@ def build_create_linked_integration_runtime_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -869,7 +869,7 @@ def build_create_linked_integration_runtime_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -920,10 +920,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeListResponse] + ) + cls: ClsType[_models.IntegrationRuntimeListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -946,7 +946,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -962,7 +962,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -970,13 +970,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("IntegrationRuntimeListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -989,7 +989,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes" + } @overload def create_or_update( @@ -1105,11 +1107,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.IntegrationRuntimeResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -1134,9 +1136,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1153,7 +1155,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}" + } @distributed_trace def get( @@ -1192,10 +1196,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.IntegrationRuntimeResource]] + ) + cls: ClsType[Optional[_models.IntegrationRuntimeResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -1209,9 +1213,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1230,7 +1234,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}" + } @overload def update( @@ -1335,11 +1341,11 @@ def update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.IntegrationRuntimeResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -1363,9 +1369,9 @@ def update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1382,7 +1388,9 @@ def update( return deserialized - update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}"} # type: ignore + update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -1412,10 +1420,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -1428,9 +1436,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1443,7 +1451,9 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}" + } @distributed_trace def get_status( @@ -1473,10 +1483,10 @@ def get_status( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeStatusResponse] + ) + cls: ClsType[_models.IntegrationRuntimeStatusResponse] = kwargs.pop("cls", None) request = build_get_status_request( resource_group_name=resource_group_name, @@ -1489,9 +1499,9 @@ def get_status( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1508,7 +1518,9 @@ def get_status( return deserialized - get_status.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getStatus"} # type: ignore + get_status.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getStatus" + } @distributed_trace def list_outbound_network_dependencies_endpoints( @@ -1540,12 +1552,10 @@ def list_outbound_network_dependencies_endpoints( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop( - "cls", None - ) # type: ClsType[_models.IntegrationRuntimeOutboundNetworkDependenciesEndpointsResponse] + ) + cls: ClsType[_models.IntegrationRuntimeOutboundNetworkDependenciesEndpointsResponse] = kwargs.pop("cls", None) request = build_list_outbound_network_dependencies_endpoints_request( resource_group_name=resource_group_name, @@ -1558,9 +1568,9 @@ def list_outbound_network_dependencies_endpoints( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1579,7 +1589,9 @@ def list_outbound_network_dependencies_endpoints( return deserialized - list_outbound_network_dependencies_endpoints.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/outboundNetworkDependenciesEndpoints"} # type: ignore + list_outbound_network_dependencies_endpoints.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/outboundNetworkDependenciesEndpoints" + } @distributed_trace def get_connection_info( @@ -1610,10 +1622,10 @@ def get_connection_info( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeConnectionInfo] + ) + cls: ClsType[_models.IntegrationRuntimeConnectionInfo] = kwargs.pop("cls", None) request = build_get_connection_info_request( resource_group_name=resource_group_name, @@ -1626,9 +1638,9 @@ def get_connection_info( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1645,7 +1657,9 @@ def get_connection_info( return deserialized - get_connection_info.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getConnectionInfo"} # type: ignore + get_connection_info.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/getConnectionInfo" + } @overload def regenerate_auth_key( @@ -1750,11 +1764,11 @@ def regenerate_auth_key( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeAuthKeys] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.IntegrationRuntimeAuthKeys] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -1778,9 +1792,9 @@ def regenerate_auth_key( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1797,7 +1811,9 @@ def regenerate_auth_key( return deserialized - regenerate_auth_key.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/regenerateAuthKey"} # type: ignore + regenerate_auth_key.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/regenerateAuthKey" + } @distributed_trace def list_auth_keys( @@ -1827,10 +1843,10 @@ def list_auth_keys( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeAuthKeys] + ) + cls: ClsType[_models.IntegrationRuntimeAuthKeys] = kwargs.pop("cls", None) request = build_list_auth_keys_request( resource_group_name=resource_group_name, @@ -1843,9 +1859,9 @@ def list_auth_keys( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1862,7 +1878,9 @@ def list_auth_keys( return deserialized - list_auth_keys.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/listAuthKeys"} # type: ignore + list_auth_keys.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/listAuthKeys" + } def _start_initial( self, resource_group_name: str, factory_name: str, integration_runtime_name: str, **kwargs: Any @@ -1878,10 +1896,10 @@ def _start_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.IntegrationRuntimeStatusResponse]] + ) + cls: ClsType[Optional[_models.IntegrationRuntimeStatusResponse]] = kwargs.pop("cls", None) request = build_start_request( resource_group_name=resource_group_name, @@ -1894,9 +1912,9 @@ def _start_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1915,7 +1933,9 @@ def _start_initial( return deserialized - _start_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/start"} # type: ignore + _start_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/start" + } @distributed_trace def begin_start( @@ -1946,15 +1966,15 @@ def begin_start( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeStatusResponse] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + cls: ClsType[_models.IntegrationRuntimeStatusResponse] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = self._start_initial( # type: ignore + raw_result = self._start_initial( resource_group_name=resource_group_name, factory_name=factory_name, integration_runtime_name=integration_runtime_name, @@ -1973,7 +1993,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -1985,9 +2005,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_start.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/start"} # type: ignore + begin_start.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/start" + } def _stop_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, factory_name: str, integration_runtime_name: str, **kwargs: Any @@ -2003,10 +2025,10 @@ def _stop_initial( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_stop_request( resource_group_name=resource_group_name, @@ -2019,9 +2041,9 @@ def _stop_initial( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -2034,7 +2056,9 @@ def _stop_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _stop_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/stop"} # type: ignore + _stop_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/stop" + } @distributed_trace def begin_stop( @@ -2063,13 +2087,13 @@ def begin_stop( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: raw_result = self._stop_initial( # type: ignore resource_group_name=resource_group_name, @@ -2088,7 +2112,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- return cls(pipeline_response, None, {}) if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -2100,9 +2124,11 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/stop"} # type: ignore + begin_stop.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/stop" + } @distributed_trace def sync_credentials( # pylint: disable=inconsistent-return-statements @@ -2135,10 +2161,10 @@ def sync_credentials( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_sync_credentials_request( resource_group_name=resource_group_name, @@ -2151,9 +2177,9 @@ def sync_credentials( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -2166,7 +2192,9 @@ def sync_credentials( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - sync_credentials.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/syncCredentials"} # type: ignore + sync_credentials.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/syncCredentials" + } @distributed_trace def get_monitoring_data( @@ -2197,10 +2225,10 @@ def get_monitoring_data( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeMonitoringData] + ) + cls: ClsType[_models.IntegrationRuntimeMonitoringData] = kwargs.pop("cls", None) request = build_get_monitoring_data_request( resource_group_name=resource_group_name, @@ -2213,9 +2241,9 @@ def get_monitoring_data( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -2232,7 +2260,9 @@ def get_monitoring_data( return deserialized - get_monitoring_data.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/monitoringData"} # type: ignore + get_monitoring_data.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/monitoringData" + } @distributed_trace def upgrade( # pylint: disable=inconsistent-return-statements @@ -2262,10 +2292,10 @@ def upgrade( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_upgrade_request( resource_group_name=resource_group_name, @@ -2278,9 +2308,9 @@ def upgrade( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -2293,7 +2323,9 @@ def upgrade( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - upgrade.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/upgrade"} # type: ignore + upgrade.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/upgrade" + } @overload def remove_links( # pylint: disable=inconsistent-return-statements @@ -2401,11 +2433,11 @@ def remove_links( # pylint: disable=inconsistent-return-statements _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[None] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -2429,9 +2461,9 @@ def remove_links( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -2444,7 +2476,9 @@ def remove_links( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - remove_links.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/removeLinks"} # type: ignore + remove_links.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/removeLinks" + } @overload def create_linked_integration_runtime( @@ -2549,11 +2583,11 @@ def create_linked_integration_runtime( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.IntegrationRuntimeStatusResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.IntegrationRuntimeStatusResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -2579,9 +2613,9 @@ def create_linked_integration_runtime( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -2598,4 +2632,6 @@ def create_linked_integration_runtime( return deserialized - create_linked_integration_runtime.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/linkedIntegrationRuntime"} # type: ignore + create_linked_integration_runtime.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/integrationRuntimes/{integrationRuntimeName}/linkedIntegrationRuntime" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_linked_services_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_linked_services_operations.py index 12f7cc7fa2d2..edca5f9d6572 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_linked_services_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_linked_services_operations.py @@ -47,7 +47,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -70,7 +70,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -93,8 +93,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -125,7 +125,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -152,7 +152,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -183,7 +183,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -202,7 +202,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -233,7 +233,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -282,10 +282,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.LinkedServiceListResponse] + ) + cls: ClsType[_models.LinkedServiceListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -308,7 +308,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -324,7 +324,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -332,13 +332,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("LinkedServiceListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -351,7 +351,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices" + } @overload def create_or_update( @@ -467,11 +469,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.LinkedServiceResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.LinkedServiceResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -496,9 +498,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -515,7 +517,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}" + } @distributed_trace def get( @@ -554,10 +558,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.LinkedServiceResource]] + ) + cls: ClsType[Optional[_models.LinkedServiceResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -571,9 +575,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -592,7 +596,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -622,10 +628,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -638,9 +644,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -653,4 +659,6 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/linkedservices/{linkedServiceName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_managed_private_endpoints_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_managed_private_endpoints_operations.py index f760cc7299fc..31a80d1807c8 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_managed_private_endpoints_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_managed_private_endpoints_operations.py @@ -47,7 +47,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -78,7 +78,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -102,8 +102,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -142,7 +142,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -170,7 +170,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -209,7 +209,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -233,7 +233,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -272,7 +272,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -324,10 +324,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedPrivateEndpointListResponse] + ) + cls: ClsType[_models.ManagedPrivateEndpointListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -351,7 +351,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -367,7 +367,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -375,13 +375,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("ManagedPrivateEndpointListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -394,7 +394,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints" + } @overload def create_or_update( @@ -520,11 +522,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedPrivateEndpointResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ManagedPrivateEndpointResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -550,9 +552,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -569,7 +571,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}" + } @distributed_trace def get( @@ -611,10 +615,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedPrivateEndpointResource] + ) + cls: ClsType[_models.ManagedPrivateEndpointResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -629,9 +633,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -648,7 +652,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -685,10 +691,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -702,9 +708,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -717,4 +723,6 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}/managedPrivateEndpoints/{managedPrivateEndpointName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_managed_virtual_networks_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_managed_virtual_networks_operations.py index 86e3fb9fad3a..96635d711132 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_managed_virtual_networks_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_managed_virtual_networks_operations.py @@ -47,7 +47,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -70,7 +70,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -93,8 +93,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -125,7 +125,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -152,7 +152,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -183,7 +183,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -235,10 +235,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedVirtualNetworkListResponse] + ) + cls: ClsType[_models.ManagedVirtualNetworkListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -261,7 +261,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -277,7 +277,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -285,13 +285,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("ManagedVirtualNetworkListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -304,7 +304,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks" + } @overload def create_or_update( @@ -421,11 +423,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedVirtualNetworkResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.ManagedVirtualNetworkResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -450,9 +452,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -469,7 +471,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}" + } @distributed_trace def get( @@ -508,10 +512,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.ManagedVirtualNetworkResource] + ) + cls: ClsType[_models.ManagedVirtualNetworkResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -525,9 +529,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -544,4 +548,6 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/managedVirtualNetworks/{managedVirtualNetworkName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_operations.py index 914825c2121d..8af29aa5b695 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_operations.py @@ -45,7 +45,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -91,10 +91,10 @@ def list(self, **kwargs: Any) -> Iterable["_models.Operation"]: _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.OperationListResponse] + ) + cls: ClsType[_models.OperationListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -114,7 +114,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -130,7 +130,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -138,13 +138,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("OperationListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -157,4 +157,4 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list.metadata = {"url": "/providers/Microsoft.DataFactory/operations"} # type: ignore + list.metadata = {"url": "/providers/Microsoft.DataFactory/operations"} diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_pipeline_runs_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_pipeline_runs_operations.py index a1415d0c6793..1686268212bf 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_pipeline_runs_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_pipeline_runs_operations.py @@ -45,8 +45,8 @@ def build_query_by_factory_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -69,7 +69,7 @@ def build_query_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -88,7 +88,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -112,7 +112,7 @@ def build_get_request( "runId": _SERIALIZER.url("run_id", run_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -135,7 +135,7 @@ def build_cancel_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -159,7 +159,7 @@ def build_cancel_request( "runId": _SERIALIZER.url("run_id", run_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters if is_recursive is not None: @@ -281,11 +281,11 @@ def query_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PipelineRunsQueryResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.PipelineRunsQueryResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -308,9 +308,9 @@ def query_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -327,7 +327,9 @@ def query_by_factory( return deserialized - query_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryPipelineRuns"} # type: ignore + query_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryPipelineRuns" + } @distributed_trace def get(self, resource_group_name: str, factory_name: str, run_id: str, **kwargs: Any) -> _models.PipelineRun: @@ -355,10 +357,10 @@ def get(self, resource_group_name: str, factory_name: str, run_id: str, **kwargs _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PipelineRun] + ) + cls: ClsType[_models.PipelineRun] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -371,9 +373,9 @@ def get(self, resource_group_name: str, factory_name: str, run_id: str, **kwargs params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -390,7 +392,9 @@ def get(self, resource_group_name: str, factory_name: str, run_id: str, **kwargs return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}" + } @distributed_trace def cancel( # pylint: disable=inconsistent-return-statements @@ -428,10 +432,10 @@ def cancel( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_cancel_request( resource_group_name=resource_group_name, @@ -445,9 +449,9 @@ def cancel( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -460,4 +464,6 @@ def cancel( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - cancel.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}/cancel"} # type: ignore + cancel.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelineruns/{runId}/cancel" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_pipelines_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_pipelines_operations.py index 1756327fca4b..aa95eb3a2fb6 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_pipelines_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_pipelines_operations.py @@ -52,7 +52,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -75,7 +75,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -98,8 +98,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -130,7 +130,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -157,7 +157,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -188,7 +188,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -207,7 +207,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -238,7 +238,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -264,8 +264,8 @@ def build_create_run_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -296,7 +296,7 @@ def build_create_run_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -356,10 +356,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PipelineListResponse] + ) + cls: ClsType[_models.PipelineListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -382,7 +382,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -398,7 +398,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -406,13 +406,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("PipelineListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -425,7 +425,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines" + } @overload def create_or_update( @@ -537,11 +539,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PipelineResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.PipelineResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -566,9 +568,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -585,7 +587,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}" + } @distributed_trace def get( @@ -624,10 +628,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.PipelineResource]] + ) + cls: ClsType[Optional[_models.PipelineResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -641,9 +645,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -662,7 +666,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -692,10 +698,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -708,9 +714,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -723,7 +729,9 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}" + } @overload def create_run( @@ -880,11 +888,11 @@ def create_run( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.CreateRunResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.CreateRunResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -915,9 +923,9 @@ def create_run( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -934,4 +942,6 @@ def create_run( return deserialized - create_run.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}/createRun"} # type: ignore + create_run.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/pipelines/{pipelineName}/createRun" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_end_point_connections_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_end_point_connections_operations.py index b075dca6b748..86407b53472d 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_end_point_connections_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_end_point_connections_operations.py @@ -47,7 +47,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -70,7 +70,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -120,10 +120,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionListResponse] + ) + cls: ClsType[_models.PrivateEndpointConnectionListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -146,7 +146,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -162,7 +162,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -170,13 +170,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("PrivateEndpointConnectionListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -189,4 +189,6 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndPointConnections"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndPointConnections" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_endpoint_connection_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_endpoint_connection_operations.py index 6acda02f8b6e..070fc6193679 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_endpoint_connection_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_endpoint_connection_operations.py @@ -51,8 +51,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -78,7 +78,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -105,7 +105,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -131,7 +131,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -154,7 +154,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -180,7 +180,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -325,11 +325,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.PrivateEndpointConnectionResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -354,9 +354,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -373,7 +373,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}" + } @distributed_trace def get( @@ -412,10 +414,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateEndpointConnectionResource] + ) + cls: ClsType[_models.PrivateEndpointConnectionResource] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -429,9 +431,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -448,7 +450,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -478,10 +482,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -494,9 +498,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -509,4 +513,6 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateEndpointConnections/{privateEndpointConnectionName}" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_link_resources_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_link_resources_operations.py index 1f25278dcdc4..c41c64876eaa 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_link_resources_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_private_link_resources_operations.py @@ -43,7 +43,7 @@ def build_get_request(resource_group_name: str, factory_name: str, subscription_ _headers = case_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -66,7 +66,7 @@ def build_get_request(resource_group_name: str, factory_name: str, subscription_ ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -120,10 +120,10 @@ def get(self, resource_group_name: str, factory_name: str, **kwargs: Any) -> _mo _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.PrivateLinkResourcesWrapper] + ) + cls: ClsType[_models.PrivateLinkResourcesWrapper] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -135,9 +135,9 @@ def get(self, resource_group_name: str, factory_name: str, **kwargs: Any) -> _mo params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -154,4 +154,6 @@ def get(self, resource_group_name: str, factory_name: str, **kwargs: Any) -> _mo return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateLinkResources"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/privateLinkResources" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_trigger_runs_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_trigger_runs_operations.py index 21f8c520e991..9f5d3a9f1d9f 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_trigger_runs_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_trigger_runs_operations.py @@ -45,7 +45,7 @@ def build_rerun_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -77,7 +77,7 @@ def build_rerun_request( "runId": _SERIALIZER.url("run_id", run_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -94,7 +94,7 @@ def build_cancel_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -126,7 +126,7 @@ def build_cancel_request( "runId": _SERIALIZER.url("run_id", run_id, "str"), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -143,8 +143,8 @@ def build_query_by_factory_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -167,7 +167,7 @@ def build_query_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -229,10 +229,10 @@ def rerun( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_rerun_request( resource_group_name=resource_group_name, @@ -246,9 +246,9 @@ def rerun( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -261,7 +261,9 @@ def rerun( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - rerun.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/triggerRuns/{runId}/rerun"} # type: ignore + rerun.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/triggerRuns/{runId}/rerun" + } @distributed_trace def cancel( # pylint: disable=inconsistent-return-statements @@ -293,10 +295,10 @@ def cancel( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_cancel_request( resource_group_name=resource_group_name, @@ -310,9 +312,9 @@ def cancel( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -325,7 +327,9 @@ def cancel( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - cancel.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/triggerRuns/{runId}/cancel"} # type: ignore + cancel.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/triggerRuns/{runId}/cancel" + } @overload def query_by_factory( @@ -417,11 +421,11 @@ def query_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerRunsQueryResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.TriggerRunsQueryResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -444,9 +448,9 @@ def query_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -463,4 +467,6 @@ def query_by_factory( return deserialized - query_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryTriggerRuns"} # type: ignore + query_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryTriggerRuns" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_triggers_operations.py b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_triggers_operations.py index bc1bf752980d..dce1c4bca555 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_triggers_operations.py +++ b/sdk/datafactory/azure-mgmt-datafactory/azure/mgmt/datafactory/operations/_triggers_operations.py @@ -49,7 +49,7 @@ def build_list_by_factory_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -72,7 +72,7 @@ def build_list_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -89,8 +89,8 @@ def build_query_by_factory_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -113,7 +113,7 @@ def build_query_by_factory_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -138,8 +138,8 @@ def build_create_or_update_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-01")) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -170,7 +170,7 @@ def build_create_or_update_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -197,7 +197,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -228,7 +228,7 @@ def build_get_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -247,7 +247,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -278,7 +278,7 @@ def build_delete_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -295,7 +295,7 @@ def build_subscribe_to_events_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -326,7 +326,7 @@ def build_subscribe_to_events_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -343,7 +343,7 @@ def build_get_event_subscription_status_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -374,7 +374,7 @@ def build_get_event_subscription_status_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -391,7 +391,7 @@ def build_unsubscribe_from_events_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -422,7 +422,7 @@ def build_unsubscribe_from_events_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -439,7 +439,7 @@ def build_start_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-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -470,7 +470,7 @@ def build_start_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -487,7 +487,7 @@ 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", "2018-06-01")) # type: Literal["2018-06-01"] + api_version: Literal["2018-06-01"] = kwargs.pop("api_version", _params.pop("api-version", "2018-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -518,7 +518,7 @@ def build_stop_request( ), } - _url = _format_url_section(_url, **path_format_arguments) + _url: str = _format_url_section(_url, **path_format_arguments) # type: ignore # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -566,10 +566,10 @@ def list_by_factory( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerListResponse] + ) + cls: ClsType[_models.TriggerListResponse] = kwargs.pop("cls", None) error_map = { 401: ClientAuthenticationError, @@ -592,7 +592,7 @@ def prepare_request(next_link=None): params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) else: # make call to next link with the client's api-version @@ -608,7 +608,7 @@ def prepare_request(next_link=None): "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) request.method = "GET" return request @@ -616,13 +616,13 @@ def extract_data(pipeline_response): deserialized = self._deserialize("TriggerListResponse", pipeline_response) list_of_elem = deserialized.value if cls: - list_of_elem = cls(list_of_elem) + list_of_elem = cls(list_of_elem) # type: ignore 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 + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response @@ -635,7 +635,9 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - list_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers"} # type: ignore + list_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers" + } @overload def query_by_factory( @@ -727,11 +729,11 @@ def query_by_factory( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerQueryResponse] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.TriggerQueryResponse] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -754,9 +756,9 @@ def query_by_factory( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -773,7 +775,9 @@ def query_by_factory( return deserialized - query_by_factory.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/querytriggers"} # type: ignore + query_by_factory.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/querytriggers" + } @overload def create_or_update( @@ -885,11 +889,11 @@ def create_or_update( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerResource] + ) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[_models.TriggerResource] = kwargs.pop("cls", None) content_type = content_type or "application/json" _json = None @@ -914,9 +918,9 @@ def create_or_update( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -933,7 +937,9 @@ def create_or_update( return deserialized - create_or_update.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}"} # type: ignore + create_or_update.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}" + } @distributed_trace def get( @@ -972,10 +978,10 @@ def get( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.TriggerResource]] + ) + cls: ClsType[Optional[_models.TriggerResource]] = kwargs.pop("cls", None) request = build_get_request( resource_group_name=resource_group_name, @@ -989,9 +995,9 @@ def get( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1010,7 +1016,9 @@ def get( return deserialized - get.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}"} # type: ignore + get.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}" + } @distributed_trace def delete( # pylint: disable=inconsistent-return-statements @@ -1040,10 +1048,10 @@ def delete( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_delete_request( resource_group_name=resource_group_name, @@ -1056,9 +1064,9 @@ def delete( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1071,7 +1079,9 @@ def delete( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}"} # type: ignore + delete.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}" + } def _subscribe_to_events_initial( self, resource_group_name: str, factory_name: str, trigger_name: str, **kwargs: Any @@ -1087,10 +1097,10 @@ def _subscribe_to_events_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.TriggerSubscriptionOperationStatus]] + ) + cls: ClsType[Optional[_models.TriggerSubscriptionOperationStatus]] = kwargs.pop("cls", None) request = build_subscribe_to_events_request( resource_group_name=resource_group_name, @@ -1103,9 +1113,9 @@ def _subscribe_to_events_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1124,7 +1134,9 @@ def _subscribe_to_events_initial( return deserialized - _subscribe_to_events_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/subscribeToEvents"} # type: ignore + _subscribe_to_events_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/subscribeToEvents" + } @distributed_trace def begin_subscribe_to_events( @@ -1155,15 +1167,15 @@ def begin_subscribe_to_events( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerSubscriptionOperationStatus] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + cls: ClsType[_models.TriggerSubscriptionOperationStatus] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = self._subscribe_to_events_initial( # type: ignore + raw_result = self._subscribe_to_events_initial( resource_group_name=resource_group_name, factory_name=factory_name, trigger_name=trigger_name, @@ -1182,7 +1194,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -1194,9 +1206,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_subscribe_to_events.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/subscribeToEvents"} # type: ignore + begin_subscribe_to_events.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/subscribeToEvents" + } @distributed_trace def get_event_subscription_status( @@ -1226,10 +1240,10 @@ def get_event_subscription_status( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerSubscriptionOperationStatus] + ) + cls: ClsType[_models.TriggerSubscriptionOperationStatus] = kwargs.pop("cls", None) request = build_get_event_subscription_status_request( resource_group_name=resource_group_name, @@ -1242,9 +1256,9 @@ def get_event_subscription_status( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1261,7 +1275,9 @@ def get_event_subscription_status( return deserialized - get_event_subscription_status.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/getEventSubscriptionStatus"} # type: ignore + get_event_subscription_status.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/getEventSubscriptionStatus" + } def _unsubscribe_from_events_initial( self, resource_group_name: str, factory_name: str, trigger_name: str, **kwargs: Any @@ -1277,10 +1293,10 @@ def _unsubscribe_from_events_initial( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[Optional[_models.TriggerSubscriptionOperationStatus]] + ) + cls: ClsType[Optional[_models.TriggerSubscriptionOperationStatus]] = kwargs.pop("cls", None) request = build_unsubscribe_from_events_request( resource_group_name=resource_group_name, @@ -1293,9 +1309,9 @@ def _unsubscribe_from_events_initial( params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1314,7 +1330,9 @@ def _unsubscribe_from_events_initial( return deserialized - _unsubscribe_from_events_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/unsubscribeFromEvents"} # type: ignore + _unsubscribe_from_events_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/unsubscribeFromEvents" + } @distributed_trace def begin_unsubscribe_from_events( @@ -1345,15 +1363,15 @@ def begin_unsubscribe_from_events( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[_models.TriggerSubscriptionOperationStatus] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + cls: ClsType[_models.TriggerSubscriptionOperationStatus] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: - raw_result = self._unsubscribe_from_events_initial( # type: ignore + raw_result = self._unsubscribe_from_events_initial( resource_group_name=resource_group_name, factory_name=factory_name, trigger_name=trigger_name, @@ -1372,7 +1390,7 @@ def get_long_running_output(pipeline_response): return deserialized if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -1384,9 +1402,11 @@ def get_long_running_output(pipeline_response): client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_unsubscribe_from_events.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/unsubscribeFromEvents"} # type: ignore + begin_unsubscribe_from_events.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/unsubscribeFromEvents" + } def _start_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, factory_name: str, trigger_name: str, **kwargs: Any @@ -1402,10 +1422,10 @@ def _start_initial( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_start_request( resource_group_name=resource_group_name, @@ -1418,9 +1438,9 @@ def _start_initial( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1433,7 +1453,9 @@ def _start_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _start_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/start"} # type: ignore + _start_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/start" + } @distributed_trace def begin_start( @@ -1462,13 +1484,13 @@ def begin_start( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: raw_result = self._start_initial( # type: ignore resource_group_name=resource_group_name, @@ -1487,7 +1509,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- return cls(pipeline_response, None, {}) if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -1499,9 +1521,11 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_start.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/start"} # type: ignore + begin_start.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/start" + } def _stop_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, factory_name: str, trigger_name: str, **kwargs: Any @@ -1517,10 +1541,10 @@ def _stop_initial( # pylint: disable=inconsistent-return-statements _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] + ) + cls: ClsType[None] = kwargs.pop("cls", None) request = build_stop_request( resource_group_name=resource_group_name, @@ -1533,9 +1557,9 @@ def _stop_initial( # pylint: disable=inconsistent-return-statements params=_params, ) request = _convert_request(request) - request.url = self._client.format_url(request.url) # type: ignore + request.url = self._client.format_url(request.url) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) @@ -1548,7 +1572,9 @@ def _stop_initial( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - _stop_initial.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/stop"} # type: ignore + _stop_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/stop" + } @distributed_trace def begin_stop( @@ -1577,13 +1603,13 @@ def begin_stop( _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop( + api_version: Literal["2018-06-01"] = kwargs.pop( "api_version", _params.pop("api-version", self._config.api_version) - ) # type: Literal["2018-06-01"] - cls = kwargs.pop("cls", None) # type: ClsType[None] - polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + ) + cls: ClsType[None] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] + cont_token: Optional[str] = kwargs.pop("continuation_token", None) if cont_token is None: raw_result = self._stop_initial( # type: ignore resource_group_name=resource_group_name, @@ -1602,7 +1628,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- return cls(pipeline_response, None, {}) if polling is True: - polling_method = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) # type: PollingMethod + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: @@ -1614,6 +1640,8 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- client=self._client, deserialization_callback=get_long_running_output, ) - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore - begin_stop.metadata = {"url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/stop"} # type: ignore + begin_stop.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/triggers/{triggerName}/stop" + } diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/approves_or_rejects_a_private_endpoint_connection_for_a_factory..py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/approve_reject_private_endpoint_connection.py similarity index 96% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/approves_or_rejects_a_private_endpoint_connection_for_a_factory..py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/approve_reject_private_endpoint_connection.py index f8640edcc31a..b88a741cd4d4 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/approves_or_rejects_a_private_endpoint_connection_for_a_factory..py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/approve_reject_private_endpoint_connection.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python approves_or_rejects_a_private_endpoint_connection_for_a_factory..py + python approve_reject_private_endpoint_connection.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_create.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_create.py new file mode 100644 index 000000000000..4ede160fa0df --- /dev/null +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_create.py @@ -0,0 +1,50 @@ +# 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 azure.identity import DefaultAzureCredential +from azure.mgmt.datafactory import DataFactoryManagementClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-datafactory +# USAGE + python credentials_create.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = DataFactoryManagementClient( + credential=DefaultAzureCredential(), + subscription_id="12345678-1234-1234-1234-12345678abc", + ) + + response = client.credential_operations.create_or_update( + resource_group_name="exampleResourceGroup", + factory_name="exampleFactoryName", + credential_name="exampleCredential", + credential={ + "properties": { + "type": "ManagedIdentity", + "typeProperties": { + "resourceId": "/subscriptions/12345678-1234-1234-1234-12345678abc/resourcegroups/exampleResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleUami" + }, + } + }, + ) + print(response) + + +# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Credentials_Create.json +if __name__ == "__main__": + main() diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_delete.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_delete.py new file mode 100644 index 000000000000..78148b9851bb --- /dev/null +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_delete.py @@ -0,0 +1,42 @@ +# 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 azure.identity import DefaultAzureCredential +from azure.mgmt.datafactory import DataFactoryManagementClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-datafactory +# USAGE + python credentials_delete.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = DataFactoryManagementClient( + credential=DefaultAzureCredential(), + subscription_id="12345678-1234-1234-1234-12345678abc", + ) + + response = client.credential_operations.delete( + resource_group_name="exampleResourceGroup", + factory_name="exampleFactoryName", + credential_name="exampleCredential", + ) + print(response) + + +# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Credentials_Delete.json +if __name__ == "__main__": + main() diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_get.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_get.py new file mode 100644 index 000000000000..96f905ccf566 --- /dev/null +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_get.py @@ -0,0 +1,42 @@ +# 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 azure.identity import DefaultAzureCredential +from azure.mgmt.datafactory import DataFactoryManagementClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-datafactory +# USAGE + python credentials_get.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = DataFactoryManagementClient( + credential=DefaultAzureCredential(), + subscription_id="12345678-1234-1234-1234-12345678abc", + ) + + response = client.credential_operations.get( + resource_group_name="exampleResourceGroup", + factory_name="exampleFactoryName", + credential_name="exampleCredential", + ) + print(response) + + +# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Credentials_Get.json +if __name__ == "__main__": + main() diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_list_by_factory.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_list_by_factory.py new file mode 100644 index 000000000000..25cea1998fe4 --- /dev/null +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/credentials_list_by_factory.py @@ -0,0 +1,42 @@ +# 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 azure.identity import DefaultAzureCredential +from azure.mgmt.datafactory import DataFactoryManagementClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-datafactory +# USAGE + python credentials_list_by_factory.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = DataFactoryManagementClient( + credential=DefaultAzureCredential(), + subscription_id="12345678-1234-1234-1234-12345678abc", + ) + + response = client.credential_operations.list_by_factory( + resource_group_name="exampleResourceGroup", + factory_name="exampleFactoryName", + ) + for item in response: + print(item) + + +# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/Credentials_ListByFactory.json +if __name__ == "__main__": + main() diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/delete_a_private_endpoint_connection_for_a_datafactory..py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/delete_private_endpoint_connection.py similarity index 95% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/delete_a_private_endpoint_connection_for_a_datafactory..py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/delete_private_endpoint_connection.py index 76a9a3141aba..7bb6b8610235 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/delete_a_private_endpoint_connection_for_a_datafactory..py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/delete_private_endpoint_connection.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python delete_a_private_endpoint_connection_for_a_datafactory..py + python delete_private_endpoint_connection.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_a_private_endpoint_connection_for_a_datafactory..py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_endpoint_connection.py similarity index 96% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_a_private_endpoint_connection_for_a_datafactory..py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_endpoint_connection.py index fe7787f9e481..7dab3ce49803 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_a_private_endpoint_connection_for_a_datafactory..py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_endpoint_connection.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python get_a_private_endpoint_connection_for_a_datafactory..py + python get_private_endpoint_connection.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_link_resources_of_a_site.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_link_resources.py similarity index 96% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_link_resources_of_a_site.py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_link_resources.py index 299e57517b73..b26c2cb41e82 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_link_resources_of_a_site.py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/get_private_link_resources.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python get_private_link_resources_of_a_site.py + python get_private_link_resources.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_nodes_delete.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtime_nodes_delete.py similarity index 97% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_nodes_delete.py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtime_nodes_delete.py index 2c422dbe0af7..890275e51b18 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_nodes_delete.py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtime_nodes_delete.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python integration_runtimes_nodes_delete.py + python integration_runtime_nodes_delete.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_outbound_network_dependencies_endpoints.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_list_outbound_network_dependencies_endpoints.py similarity index 95% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_outbound_network_dependencies_endpoints.py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_list_outbound_network_dependencies_endpoints.py index 74fd753477bf..5aec3d9a1ab4 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_outbound_network_dependencies_endpoints.py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_list_outbound_network_dependencies_endpoints.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python integration_runtimes_outbound_network_dependencies_endpoints.py + python integration_runtimes_list_outbound_network_dependencies_endpoints.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_remove_links.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_remove_links.py new file mode 100644 index 000000000000..a77b0dc65e70 --- /dev/null +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/integration_runtimes_remove_links.py @@ -0,0 +1,43 @@ +# 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 azure.identity import DefaultAzureCredential +from azure.mgmt.datafactory import DataFactoryManagementClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-datafactory +# USAGE + python integration_runtimes_remove_links.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = DataFactoryManagementClient( + credential=DefaultAzureCredential(), + subscription_id="12345678-1234-1234-1234-12345678abc", + ) + + response = client.integration_runtimes.remove_links( + resource_group_name="exampleResourceGroup", + factory_name="exampleFactoryName", + integration_runtime_name="exampleIntegrationRuntime", + linked_integration_runtime_request={"factoryName": "exampleFactoryName-linked"}, + ) + print(response) + + +# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/IntegrationRuntimes_RemoveLinks.json +if __name__ == "__main__": + main() diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_private_endpoints_create.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_private_endpoints_create.py new file mode 100644 index 000000000000..b13df906e445 --- /dev/null +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_private_endpoints_create.py @@ -0,0 +1,50 @@ +# 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 azure.identity import DefaultAzureCredential +from azure.mgmt.datafactory import DataFactoryManagementClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-datafactory +# USAGE + python managed_private_endpoints_create.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = DataFactoryManagementClient( + credential=DefaultAzureCredential(), + subscription_id="12345678-1234-1234-1234-12345678abc", + ) + + response = client.managed_private_endpoints.create_or_update( + resource_group_name="exampleResourceGroup", + factory_name="exampleFactoryName", + managed_virtual_network_name="exampleManagedVirtualNetworkName", + managed_private_endpoint_name="exampleManagedPrivateEndpointName", + managed_private_endpoint={ + "properties": { + "fqdns": [], + "groupId": "blob", + "privateLinkResourceId": "/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.Storage/storageAccounts/exampleBlobStorage", + } + }, + ) + print(response) + + +# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/ManagedPrivateEndpoints_Create.json +if __name__ == "__main__": + main() diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_virtual_networks_delete.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_private_endpoints_delete.py similarity index 97% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_virtual_networks_delete.py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_private_endpoints_delete.py index 8b3d84b1d80b..430542ebcbfe 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_virtual_networks_delete.py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/managed_private_endpoints_delete.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python managed_virtual_networks_delete.py + python managed_private_endpoints_delete.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/triggers_cancel.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/trigger_runs_cancel.py similarity index 97% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/triggers_cancel.py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/trigger_runs_cancel.py index fd6e1ab8c301..53f5958809d7 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/triggers_cancel.py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/trigger_runs_cancel.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python triggers_cancel.py + python trigger_runs_cancel.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, diff --git a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/triggers_rerun.py b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/trigger_runs_rerun.py similarity index 98% rename from sdk/datafactory/azure-mgmt-datafactory/generated_samples/triggers_rerun.py rename to sdk/datafactory/azure-mgmt-datafactory/generated_samples/trigger_runs_rerun.py index 36457ea8a179..17237b977b04 100644 --- a/sdk/datafactory/azure-mgmt-datafactory/generated_samples/triggers_rerun.py +++ b/sdk/datafactory/azure-mgmt-datafactory/generated_samples/trigger_runs_rerun.py @@ -14,7 +14,7 @@ pip install azure-identity pip install azure-mgmt-datafactory # USAGE - python triggers_rerun.py + python trigger_runs_rerun.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,