def build_create_or_update_collection_request( collection_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest content_type = kwargs.pop('content_type', None) # type: Optional[str] api_version = "2019-11-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/collections/{collectionName}') path_format_arguments = { "collectionName": _SERIALIZER.url("collection_name", collection_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: header_parameters['Content-Type'] = _SERIALIZER.header( "content_type", content_type, 'str') header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="PUT", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_query_id_by_content_request(group_name: str, schema_name: str, *, content: Any, serialization_type: str, **kwargs: Any) -> HttpRequest: """Get ID for existing schema. Gets the ID referencing an existing schema within the specified schema group, as matched by schema content comparison. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param group_name: Schema group under which schema is registered. Group's serialization type should match the serialization type specified in the request. :type group_name: str :param schema_name: Name of the registered schema. :type schema_name: str :keyword content: Pass in binary content you want in the body of the request (typically bytes, a byte iterator, or stream input). String representation (UTF-8) of the registered schema. :paramtype content: any :keyword serialization_type: Serialization type for the schema being registered. "avro" :paramtype serialization_type: str :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.core.rest.HttpRequest """ content_type = kwargs.pop('content_type', None) # type: Optional[str] api_version = "2020-09-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/$schemagroups/{group-name}/schemas/{schema-name}') path_format_arguments = { 'group-name': _SERIALIZER.url("group_name", group_name, 'str'), 'schema-name': _SERIALIZER.url("schema_name", schema_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Serialization-Type'] = _SERIALIZER.header( "serialization_type", serialization_type, 'str') if content_type is not None: header_parameters['Content-Type'] = _SERIALIZER.header( "content_type", content_type, 'str') header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="POST", url=url, params=query_parameters, headers=header_parameters, content=content, **kwargs)
def build_get_collection_path_request( collection_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest api_version = "2019-11-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/collections/{collectionName}/getCollectionPath') path_format_arguments = { "collectionName": _SERIALIZER.url("collection_name", collection_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_delete_request( guid, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Delete a relationship between entities by its GUID. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param guid: The globally unique identifier of the relationship. :type guid: str :return: Returns an :class:`~azure.purview.catalog.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.catalog.core.rest.HttpRequest """ # Construct URL url = kwargs.pop("template_url", '/atlas/v2/relationship/guid/{guid}') path_format_arguments = { 'guid': _SERIALIZER.url("guid", guid, 'str', max_length=4096, min_length=1), } url = _format_url_section(url, **path_format_arguments) return HttpRequest(method="DELETE", url=url, **kwargs)
def build_list_versions_by_classification_rule_name_request( classification_rule_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Lists the rule versions of a classification rule. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param classification_rule_name: :type classification_rule_name: str :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 200 response_body == { "count": "long (optional)", "nextLink": "str (optional)", "value": [ { "kind": "ClassificationRule" } ] } """ api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/classificationrules/{classificationRuleName}/versions') path_format_arguments = { 'classificationRuleName': _SERIALIZER.url("classification_rule_name", classification_rule_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_get_by_version_request( version, # type: int **kwargs # type: Any ): # type: (...) -> HttpRequest """Get a scan ruleset by version. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param version: :type version: int :keyword data_source_type: :paramtype data_source_type: str or ~azure.purview.scanning.models.DataSourceType :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 200 response_body == { "kind": "SystemScanRuleset" } """ data_source_type = kwargs.pop( 'data_source_type', None) # type: Optional[Union[str, "_models.DataSourceType"]] api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/systemScanRulesets/versions/{version}') path_format_arguments = { 'version': _SERIALIZER.url("version", version, 'int'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if data_source_type is not None: query_parameters['dataSourceType'] = _SERIALIZER.query( "data_source_type", data_source_type, 'str') query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_get_trigger_request( data_source_name, # type: str scan_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Gets trigger information. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param data_source_name: :type data_source_name: str :param scan_name: :type scan_name: str :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 200 response_body == { "properties": {} } """ api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop( "template_url", '/datasources/{dataSourceName}/scans/{scanName}/triggers/default') path_format_arguments = { 'dataSourceName': _SERIALIZER.url("data_source_name", data_source_name, 'str'), 'scanName': _SERIALIZER.url("scan_name", scan_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_remove_connection_from_group_request( hub, # type: str group, # type: str connection_id, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Remove a connection from the target group. Remove a connection from the target group. See https://aka.ms/azsdk/python/llcwiki for how to incorporate this request builder into your code flow. :param hub: Target hub name, which should start with alphabetic characters and only contain alpha-numeric characters or underscore. :type hub: str :param group: Target group name, which length should be greater than 0 and less than 1025. :type group: str :param connection_id: Target connection Id. :type connection_id: str :keyword api_version: Api Version. :paramtype api_version: str :return: Returns an :class:`~azure.messaging.webpubsubservice.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/llcwiki for how to incorporate this response into your code flow. :rtype: ~azure.messaging.webpubsubservice.core.rest.HttpRequest """ api_version = kwargs.pop('api_version', "2021-05-01-preview") # type: Optional[str] # Construct URL url = kwargs.pop( "template_url", '/api/hubs/{hub}/groups/{group}/connections/{connectionId}') path_format_arguments = { 'hub': _SERIALIZER.url("hub", hub, 'str', pattern=r'^[A-Za-z][A-Za-z0-9_`,.[\]]{0,127}$'), 'group': _SERIALIZER.url("group", group, 'str', max_length=1024, min_length=1), 'connectionId': _SERIALIZER.url("connection_id", connection_id, 'str', min_length=1), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if api_version is not None: query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') return HttpRequest(method="DELETE", url=url, params=query_parameters, **kwargs)
def build_delete_request( scan_ruleset_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Deletes a scan ruleset. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param scan_ruleset_name: :type scan_ruleset_name: str :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 200 response_body == { "kind": "ScanRuleset" } """ api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/scanrulesets/{scanRulesetName}') path_format_arguments = { 'scanRulesetName': _SERIALIZER.url("scan_ruleset_name", scan_ruleset_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="DELETE", url=url, params=query_parameters, headers=header_parameters, **kwargs )
def build_user_exists_request( hub, # type: str user_id, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Check if there are any client connections connected for the given user. Check if there are any client connections connected for the given user. See https://aka.ms/azsdk/python/llcwiki for how to incorporate this request builder into your code flow. :param hub: Target hub name, which should start with alphabetic characters and only contain alpha-numeric characters or underscore. :type hub: str :param user_id: Target user Id. :type user_id: str :keyword api_version: Api Version. :paramtype api_version: str :return: Returns an :class:`~azure.messaging.webpubsubservice.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/llcwiki for how to incorporate this response into your code flow. :rtype: ~azure.messaging.webpubsubservice.core.rest.HttpRequest """ api_version = kwargs.pop('api_version', "2021-05-01-preview") # type: Optional[str] # Construct URL url = kwargs.pop("template_url", '/api/hubs/{hub}/users/{userId}') path_format_arguments = { 'hub': _SERIALIZER.url("hub", hub, 'str', pattern=r'^[A-Za-z][A-Za-z0-9_`,.[\]]{0,127}$'), 'userId': _SERIALIZER.url("user_id", user_id, 'str', min_length=1), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if api_version is not None: query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') return HttpRequest(method="HEAD", url=url, params=query_parameters, **kwargs)
def build_get_by_id_request( schema_id, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Get a registered schema by its unique ID reference. Gets a registered schema by its unique ID. Azure Schema Registry guarantees that ID is unique within a namespace. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param schema_id: References specific schema in registry namespace. :type schema_id: str :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.core.rest.HttpRequest """ api_version = "2020-09-01-preview" accept = "text/plain; charset=utf-8" # Construct URL url = kwargs.pop("template_url", '/$schemagroups/getSchemaById/{schema-id}') path_format_arguments = { 'schema-id': _SERIALIZER.url("schema_id", schema_id, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_get_request( guid, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Get relationship information between entities by its GUID. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param guid: The globally unique identifier of the relationship. :type guid: str :keyword extended_info: Limits whether includes extended information. :paramtype extended_info: bool :return: Returns an :class:`~azure.purview.catalog.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.catalog.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 200 response_body == { "referredEntities": { "str": { "classificationNames": [ "str (optional)" ], "classifications": [ { "entityGuid": "str (optional)", "entityStatus": "str (optional)", "removePropagationsOnEntityDelete": "bool (optional)", "source": "str (optional)", "sourceDetails": { "str": "object (optional)" }, "validityPeriods": [ { "endTime": "str (optional)", "startTime": "str (optional)", "timeZone": "str (optional)" } ] } ], "displayText": "str (optional)", "guid": "str (optional)", "meaningNames": [ "str (optional)" ], "meanings": [ { "confidence": "int (optional)", "createdBy": "str (optional)", "description": "str (optional)", "displayText": "str (optional)", "expression": "str (optional)", "relationGuid": "str (optional)", "source": "str (optional)", "status": "str (optional)", "steward": "str (optional)", "termGuid": "str (optional)" } ], "status": "str (optional)" } }, "relationship": { "createTime": "float (optional)", "createdBy": "str (optional)", "end1": { "guid": "str (optional)", "typeName": "str (optional)", "uniqueAttributes": { "str": "object (optional)" } }, "end2": { "guid": "str (optional)", "typeName": "str (optional)", "uniqueAttributes": { "str": "object (optional)" } }, "guid": "str (optional)", "homeId": "str (optional)", "label": "str (optional)", "provenanceType": "float (optional)", "status": "str (optional)", "updateTime": "float (optional)", "updatedBy": "str (optional)", "version": "float (optional)" } } """ extended_info = kwargs.pop('extended_info', None) # type: Optional[bool] accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/atlas/v2/relationship/guid/{guid}') path_format_arguments = { 'guid': _SERIALIZER.url("guid", guid, 'str', max_length=4096, min_length=1), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if extended_info is not None: query_parameters['extendedInfo'] = _SERIALIZER.query( "extended_info", extended_info, 'bool') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_send_to_all_request( hub, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Broadcast content inside request body to all the connected client connections. Broadcast content inside request body to all the connected client connections. See https://aka.ms/azsdk/python/llcwiki for how to incorporate this request builder into your code flow. :param hub: Target hub name, which should start with alphabetic characters and only contain alpha-numeric characters or underscore. :type hub: str :keyword json: The payload body. :paramtype json: Any :keyword content: The payload body. :paramtype content: IO :keyword excluded: Excluded connection Ids. :paramtype excluded: list[str] :keyword api_version: Api Version. :paramtype api_version: str :return: Returns an :class:`~azure.messaging.webpubsubservice.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/llcwiki for how to incorporate this response into your code flow. :rtype: ~azure.messaging.webpubsubservice.core.rest.HttpRequest Example: .. code-block:: python # JSON input template you can fill out and use as your `json` input. json = "Any (optional)" """ excluded = kwargs.pop('excluded', None) # type: Optional[List[str]] api_version = kwargs.pop('api_version', "2021-05-01-preview") # type: Optional[str] content_type = kwargs.pop("content_type", None) # Construct URL url = kwargs.pop("template_url", '/api/hubs/{hub}/:send') path_format_arguments = { 'hub': _SERIALIZER.url("hub", hub, 'str', pattern=r'^[A-Za-z][A-Za-z0-9_`,.[\]]{0,127}$'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if excluded is not None: query_parameters['excluded'] = [ _SERIALIZER.query("excluded", q, 'str') if q is not None else '' for q in excluded ] if api_version is not None: query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: header_parameters['Content-Type'] = _SERIALIZER.header( "content_type", content_type, 'str') return HttpRequest(method="POST", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_check_permission_request( hub, # type: str permission, # type: Permissions connection_id, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Check if a connection has permission to the specified action. Check if a connection has permission to the specified action. See https://aka.ms/azsdk/python/llcwiki for how to incorporate this request builder into your code flow. :param hub: Target hub name, which should start with alphabetic characters and only contain alpha-numeric characters or underscore. :type hub: str :param permission: The permission: current supported actions are joinLeaveGroup and sendToGroup. :type permission: ~Permissions :param connection_id: Target connection Id. :type connection_id: str :keyword target_name: Optional. If not set, get the permission for all targets. If set, get the permission for the specific target. The meaning of the target depends on the specific permission. :paramtype target_name: str :keyword api_version: Api Version. :paramtype api_version: str :return: Returns an :class:`~azure.messaging.webpubsubservice.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/llcwiki for how to incorporate this response into your code flow. :rtype: ~azure.messaging.webpubsubservice.core.rest.HttpRequest """ target_name = kwargs.pop('target_name', None) # type: Optional[str] api_version = kwargs.pop('api_version', "2021-05-01-preview") # type: Optional[str] # Construct URL url = kwargs.pop( "template_url", '/api/hubs/{hub}/permissions/{permission}/connections/{connectionId}') path_format_arguments = { 'hub': _SERIALIZER.url("hub", hub, 'str', pattern=r'^[A-Za-z][A-Za-z0-9_`,.[\]]{0,127}$'), 'permission': _SERIALIZER.url("permission", permission, 'str'), 'connectionId': _SERIALIZER.url("connection_id", connection_id, 'str', min_length=1), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if target_name is not None: query_parameters['targetName'] = _SERIALIZER.query( "target_name", target_name, 'str') if api_version is not None: query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') return HttpRequest(method="HEAD", url=url, params=query_parameters, **kwargs)
def build_create_or_update_request( data_source_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Creates or Updates a data source. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param data_source_name: :type data_source_name: str :keyword json: :paramtype json: Any :keyword content: :paramtype content: Any :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # kind template as part of your input body kind = 'AdlsGen1DataSource' or 'AdlsGen2DataSource' or 'AmazonAccountDataSource' or 'AmazonPostgreSqlDataSource' or 'AmazonS3DataSource' or 'AmazonSqlDataSource' or 'AzureCosmosDbDataSource' or 'AzureDataExplorerDataSource' or 'AzureFileServiceDataSource' or 'AzureMySqlDataSource' or 'AzurePostgreSqlDataSource' or 'AzureResourceGroupDataSource' or 'AzureSqlDataWarehouseDataSource' or 'AzureSqlDatabaseDataSource' or 'AzureSqlDatabaseManagedInstanceDataSource' or 'AzureStorageDataSource' or 'AzureSubscriptionDataSource' or 'AzureSynapseDataSource' or 'AzureSynapseWorkspaceDataSource' or 'OracleDataSource' or 'PowerBIDataSource' or 'SapEccDataSource' or 'SapS4HanaDataSource' or 'SqlServerDatabaseDataSource' or 'TeradataDataSource' # JSON input template you can fill out and use as your `json` input. json = { "kind": "DataSource", "scans": [ { "kind": "Scan", "scanResults": [ { "assetsClassified": "long (optional)", "assetsDiscovered": "long (optional)", "dataSourceType": "str (optional)", "diagnostics": {}, "endTime": "datetime (optional)", "error": {}, "errorMessage": "str (optional)", "id": "str (optional)", "parentId": "str (optional)", "pipelineStartTime": "datetime (optional)", "queuedTime": "datetime (optional)", "resourceId": "str (optional)", "runType": "str (optional)", "scanLevelType": "str (optional)", "scanRulesetType": "str (optional)", "scanRulesetVersion": "int (optional)", "startTime": "datetime (optional)", "status": "str (optional)" } ] } ] } # response body for status code(s): 200, 201 response_body == { "kind": "DataSource", "scans": [ { "kind": "Scan", "scanResults": [ { "assetsClassified": "long (optional)", "assetsDiscovered": "long (optional)", "dataSourceType": "str (optional)", "diagnostics": {}, "endTime": "datetime (optional)", "error": {}, "errorMessage": "str (optional)", "id": "str (optional)", "parentId": "str (optional)", "pipelineStartTime": "datetime (optional)", "queuedTime": "datetime (optional)", "resourceId": "str (optional)", "runType": "str (optional)", "scanLevelType": "str (optional)", "scanRulesetType": "str (optional)", "scanRulesetVersion": "int (optional)", "startTime": "datetime (optional)", "status": "str (optional)" } ] } ] } """ content_type = kwargs.pop("content_type", None) api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/datasources/{dataSourceName}') path_format_arguments = { 'dataSourceName': _SERIALIZER.url("data_source_name", data_source_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="PUT", url=url, params=query_parameters, headers=header_parameters, **kwargs )
def build_list_scan_history_request( data_source_name, # type: str scan_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Lists the scan history of a scan. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param data_source_name: :type data_source_name: str :param scan_name: :type scan_name: str :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 200 response_body == { "count": "long (optional)", "nextLink": "str (optional)", "value": [ { "assetsClassified": "long (optional)", "assetsDiscovered": "long (optional)", "dataSourceType": "str (optional)", "diagnostics": {}, "endTime": "datetime (optional)", "error": {}, "errorMessage": "str (optional)", "id": "str (optional)", "parentId": "str (optional)", "pipelineStartTime": "datetime (optional)", "queuedTime": "datetime (optional)", "resourceId": "str (optional)", "runType": "str (optional)", "scanLevelType": "str (optional)", "scanRulesetType": "str (optional)", "scanRulesetVersion": "int (optional)", "startTime": "datetime (optional)", "status": "str (optional)" } ] } """ api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/datasources/{dataSourceName}/scans/{scanName}/runs') path_format_arguments = { 'dataSourceName': _SERIALIZER.url("data_source_name", data_source_name, 'str'), 'scanName': _SERIALIZER.url("scan_name", scan_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_tag_classification_version_request( classification_rule_name, # type: str classification_rule_version, # type: int **kwargs # type: Any ): # type: (...) -> HttpRequest """Sets Classification Action on a specific classification rule version. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param classification_rule_name: :type classification_rule_name: str :param classification_rule_version: :type classification_rule_version: int :keyword action: :paramtype action: str or ~azure.purview.scanning.models.ClassificationAction :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 202 response_body == { "endTime": "datetime (optional)", "error": {}, "scanResultId": "str (optional)", "startTime": "datetime (optional)", "status": "str (optional)" } """ action = kwargs.pop( 'action') # type: Union[str, "_models.ClassificationAction"] api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop( "template_url", '/classificationrules/{classificationRuleName}/versions/{classificationRuleVersion}/:tag' ) path_format_arguments = { 'classificationRuleName': _SERIALIZER.url("classification_rule_name", classification_rule_name, 'str'), 'classificationRuleVersion': _SERIALIZER.url("classification_rule_version", classification_rule_version, 'int'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['action'] = _SERIALIZER.query("action", action, 'str') query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="POST", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_create_or_update_request( scan_ruleset_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Creates or Updates a scan ruleset. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param scan_ruleset_name: :type scan_ruleset_name: str :keyword json: :paramtype json: Any :keyword content: :paramtype content: Any :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # kind template as part of your input body kind = 'AdlsGen1ScanRuleset' or 'AdlsGen2ScanRuleset' or 'AmazonAccountScanRuleset' or 'AmazonPostgreSqlScanRuleset' or 'AmazonS3ScanRuleset' or 'AmazonSqlScanRuleset' or 'AzureCosmosDbScanRuleset' or 'AzureDataExplorerScanRuleset' or 'AzureFileServiceScanRuleset' or 'AzureMySqlScanRuleset' or 'AzurePostgreSqlScanRuleset' or 'AzureResourceGroupScanRuleset' or 'AzureSqlDataWarehouseScanRuleset' or 'AzureSqlDatabaseScanRuleset' or 'AzureSqlDatabaseManagedInstanceScanRuleset' or 'AzureStorageScanRuleset' or 'AzureSubscriptionScanRuleset' or 'AzureSynapseScanRuleset' or 'AzureSynapseWorkspaceScanRuleset' or 'OracleScanRuleset' or 'PowerBIScanRuleset' or 'SapEccScanRuleset' or 'SapS4HanaScanRuleset' or 'SqlServerDatabaseScanRuleset' or 'TeradataScanRuleset' # JSON input template you can fill out and use as your `json` input. json = { "kind": "ScanRuleset" } # response body for status code(s): 200, 201 response_body == { "kind": "ScanRuleset" } """ content_type = kwargs.pop("content_type", None) api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/scanrulesets/{scanRulesetName}') path_format_arguments = { 'scanRulesetName': _SERIALIZER.url("scan_ruleset_name", scan_ruleset_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="PUT", url=url, params=query_parameters, headers=header_parameters, **kwargs )
def build_next_page_lineage_request( guid, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Return immediate next page lineage info about entity with pagination. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param guid: The globally unique identifier of the entity. :type guid: str :keyword direction: The direction of the lineage, which could be INPUT, OUTPUT or BOTH. :paramtype direction: str or ~azure.purview.catalog.models.Direction :keyword get_derived_lineage: True to include derived lineage in the response. :paramtype get_derived_lineage: bool :keyword offset: The offset for pagination purpose. :paramtype offset: int :keyword limit: The page size - by default there is no paging. :paramtype limit: int :return: Returns an :class:`~azure.purview.catalog.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.catalog.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 200 response_body == { "baseEntityGuid": "str (optional)", "childrenCount": "int (optional)", "guidEntityMap": { "str": { "classificationNames": [ "str (optional)" ], "classifications": [ { "entityGuid": "str (optional)", "entityStatus": "str (optional)", "removePropagationsOnEntityDelete": "bool (optional)", "source": "str (optional)", "sourceDetails": { "str": "object (optional)" }, "validityPeriods": [ { "endTime": "str (optional)", "startTime": "str (optional)", "timeZone": "str (optional)" } ] } ], "displayText": "str (optional)", "guid": "str (optional)", "meaningNames": [ "str (optional)" ], "meanings": [ { "confidence": "int (optional)", "createdBy": "str (optional)", "description": "str (optional)", "displayText": "str (optional)", "expression": "str (optional)", "relationGuid": "str (optional)", "source": "str (optional)", "status": "str (optional)", "steward": "str (optional)", "termGuid": "str (optional)" } ], "status": "str (optional)" } }, "includeParent": "bool (optional)", "lineageDepth": "int (optional)", "lineageDirection": "str (optional)", "lineageWidth": "int (optional)", "parentRelations": [ { "childEntityId": "str (optional)", "parentEntityId": "str (optional)", "relationshipId": "str (optional)" } ], "relations": [ { "fromEntityId": "str (optional)", "relationshipId": "str (optional)", "toEntityId": "str (optional)" } ], "widthCounts": { "str": { "str": "object (optional)" } } } """ direction = kwargs.pop( 'direction') # type: Union[str, "_models.Direction"] get_derived_lineage = kwargs.pop('get_derived_lineage', None) # type: Optional[bool] offset = kwargs.pop('offset', None) # type: Optional[int] limit = kwargs.pop('limit', None) # type: Optional[int] api_version = "2021-05-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/lineage/{guid}/next/') path_format_arguments = { 'guid': _SERIALIZER.url("guid", guid, 'str', max_length=4096, min_length=1), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['direction'] = _SERIALIZER.query("direction", direction, 'str') if get_derived_lineage is not None: query_parameters['getDerivedLineage'] = _SERIALIZER.query( "get_derived_lineage", get_derived_lineage, 'bool') if offset is not None: query_parameters['offset'] = _SERIALIZER.query("offset", offset, 'int') if limit is not None: query_parameters['limit'] = _SERIALIZER.query("limit", limit, 'int') query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_create_or_update_request( classification_rule_name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Creates or Updates a classification rule. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param classification_rule_name: :type classification_rule_name: str :keyword json: :paramtype json: Any :keyword content: :paramtype content: Any :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # kind template as part of your input body kind = 'CustomClassificationRule' or 'SystemClassificationRule' # JSON input template you can fill out and use as your `json` input. json = { "kind": "ClassificationRule" } # response body for status code(s): 200, 201 response_body == { "kind": "ClassificationRule" } """ content_type = kwargs.pop("content_type", None) api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/classificationrules/{classificationRuleName}') path_format_arguments = { 'classificationRuleName': _SERIALIZER.url("classification_rule_name", classification_rule_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: header_parameters['Content-Type'] = _SERIALIZER.header( "content_type", content_type, 'str') header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="PUT", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_get_lineage_graph_request( guid, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Get lineage info of the entity specified by GUID. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param guid: The globally unique identifier of the entity. :type guid: str :keyword direction: The direction of the lineage, which could be INPUT, OUTPUT or BOTH. :paramtype direction: str or ~azure.purview.catalog.models.Direction :keyword depth: The number of hops for lineage. :paramtype depth: int :keyword width: The number of max expanding width in lineage. :paramtype width: int :keyword include_parent: True to include the parent chain in the response. :paramtype include_parent: bool :keyword get_derived_lineage: True to include derived lineage in the response. :paramtype get_derived_lineage: bool :return: Returns an :class:`~azure.purview.catalog.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.catalog.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 200 response_body == { "baseEntityGuid": "str (optional)", "childrenCount": "int (optional)", "guidEntityMap": { "str": { "classificationNames": [ "str (optional)" ], "classifications": [ { "entityGuid": "str (optional)", "entityStatus": "str (optional)", "removePropagationsOnEntityDelete": "bool (optional)", "source": "str (optional)", "sourceDetails": { "str": "object (optional)" }, "validityPeriods": [ { "endTime": "str (optional)", "startTime": "str (optional)", "timeZone": "str (optional)" } ] } ], "displayText": "str (optional)", "guid": "str (optional)", "meaningNames": [ "str (optional)" ], "meanings": [ { "confidence": "int (optional)", "createdBy": "str (optional)", "description": "str (optional)", "displayText": "str (optional)", "expression": "str (optional)", "relationGuid": "str (optional)", "source": "str (optional)", "status": "str (optional)", "steward": "str (optional)", "termGuid": "str (optional)" } ], "status": "str (optional)" } }, "includeParent": "bool (optional)", "lineageDepth": "int (optional)", "lineageDirection": "str (optional)", "lineageWidth": "int (optional)", "parentRelations": [ { "childEntityId": "str (optional)", "parentEntityId": "str (optional)", "relationshipId": "str (optional)" } ], "relations": [ { "fromEntityId": "str (optional)", "relationshipId": "str (optional)", "toEntityId": "str (optional)" } ], "widthCounts": { "str": { "str": "object (optional)" } } } """ direction = kwargs.pop( 'direction') # type: Union[str, "_models.Direction"] depth = kwargs.pop('depth', 3) # type: Optional[int] width = kwargs.pop('width', 10) # type: Optional[int] include_parent = kwargs.pop('include_parent', None) # type: Optional[bool] get_derived_lineage = kwargs.pop('get_derived_lineage', None) # type: Optional[bool] accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/atlas/v2/lineage/{guid}') path_format_arguments = { 'guid': _SERIALIZER.url("guid", guid, 'str', max_length=4096, min_length=1), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if depth is not None: query_parameters['depth'] = _SERIALIZER.query("depth", depth, 'int') if width is not None: query_parameters['width'] = _SERIALIZER.query("width", width, 'int') query_parameters['direction'] = _SERIALIZER.query("direction", direction, 'str') if include_parent is not None: query_parameters['includeParent'] = _SERIALIZER.query( "include_parent", include_parent, 'bool') if get_derived_lineage is not None: query_parameters['getDerivedLineage'] = _SERIALIZER.query( "get_derived_lineage", get_derived_lineage, 'bool') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_run_scan_request( data_source_name, # type: str scan_name, # type: str run_id, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest """Runs the scan. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param data_source_name: :type data_source_name: str :param scan_name: :type scan_name: str :param run_id: :type run_id: str :keyword scan_level: :paramtype scan_level: str or ~azure.purview.scanning.models.ScanLevelType :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # response body for status code(s): 202 response_body == { "endTime": "datetime (optional)", "error": {}, "scanResultId": "str (optional)", "startTime": "datetime (optional)", "status": "str (optional)" } """ scan_level = kwargs.pop( 'scan_level', None) # type: Optional[Union[str, "_models.ScanLevelType"]] api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop( "template_url", '/datasources/{dataSourceName}/scans/{scanName}/runs/{runId}') path_format_arguments = { 'dataSourceName': _SERIALIZER.url("data_source_name", data_source_name, 'str'), 'scanName': _SERIALIZER.url("scan_name", scan_name, 'str'), 'runId': _SERIALIZER.url("run_id", run_id, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if scan_level is not None: query_parameters['scanLevel'] = _SERIALIZER.query( "scan_level", scan_level, 'str') query_parameters['api-version'] = _SERIALIZER.query( "api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="PUT", url=url, params=query_parameters, headers=header_parameters, **kwargs)
def build_create_trigger_request( data_source_name: str, scan_name: str, *, json: Any = None, content: Any = None, **kwargs: Any ) -> HttpRequest: """Creates an instance of a trigger. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder into your code flow. :param data_source_name: :type data_source_name: str :param scan_name: :type scan_name: str :keyword json: :paramtype json: Any :keyword content: :paramtype content: Any :return: Returns an :class:`~azure.purview.scanning.core.rest.HttpRequest` that you will pass to the client's `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this response into your code flow. :rtype: ~azure.purview.scanning.core.rest.HttpRequest Example: .. code-block:: python # JSON input template you can fill out and use as your `json` input. json = { "properties": {} } # response body for status code(s): 200, 201 response_body == { "properties": {} } """ content_type = kwargs.pop("content_type", None) api_version = "2018-12-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/datasources/{dataSourceName}/scans/{scanName}/triggers/default') path_format_arguments = { 'dataSourceName': _SERIALIZER.url("data_source_name", data_source_name, 'str'), 'scanName': _SERIALIZER.url("scan_name", scan_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="PUT", url=url, params=query_parameters, headers=header_parameters, json=json, content=content, **kwargs )