diff options
Diffstat (limited to '.venv/lib/python3.12/site-packages/azure/ai/ml/_utils')
44 files changed, 28210 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/__init__.py new file mode 100644 index 00000000..29a4fcd3 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/__init__.py @@ -0,0 +1,5 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +__path__ = __import__("pkgutil").extend_path(__path__, __name__) # type: ignore diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_appinsights_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_appinsights_utils.py new file mode 100644 index 00000000..579ece7a --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_appinsights_utils.py @@ -0,0 +1,16 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import logging + +module_logger = logging.getLogger(__name__) + + +def get_log_analytics_arm_id(subscription_id: str, resource_group_name: str, log_analytics_name: str) -> str: + return ( + f"/subscriptions/{subscription_id}/" + f"resourceGroups/{resource_group_name}/" + "providers/Microsoft.OperationalInsights/workspaces/" + f"{log_analytics_name}" + ) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_arm_id_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_arm_id_utils.py new file mode 100644 index 00000000..83545b9d --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_arm_id_utils.py @@ -0,0 +1,506 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import logging +import re +from typing import Any, Optional, Tuple, Union + +from azure.ai.ml._scope_dependent_operations import OperationScope +from azure.ai.ml.constants._common import ( + ARM_ID_PREFIX, + ASSET_ID_URI_REGEX_FORMAT, + AZUREML_RESOURCE_PROVIDER, + DATA_ARM_TYPE, + DATASTORE_RESOURCE_ID, + DATASTORE_SHORT_URI, + LEVEL_ONE_NAMED_RESOURCE_ID_FORMAT, + NAMED_RESOURCE_ID_FORMAT, + NAMED_RESOURCE_ID_FORMAT_WITH_PARENT, + PROVIDER_RESOURCE_ID_WITH_VERSION, + REGISTRY_URI_REGEX_FORMAT, + REGISTRY_VERSION_PATTERN, + SINGULARITY_FULL_NAME_REGEX_FORMAT, + SINGULARITY_ID_REGEX_FORMAT, + SINGULARITY_SHORT_NAME_REGEX_FORMAT, +) +from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException + +module_logger = logging.getLogger(__name__) + + +class AMLVersionedArmId(object): + """Parser for versioned arm id: e.g. /subscription/.../code/my- code/versions/1. + + :param arm_id: The versioned ARM id. + :type arm_id: str + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the ARM id is incorrectly formatted. + """ + + REGEX_PATTERN = ( + "^/?subscriptions/([^/]+)/resourceGroups/([" + "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)/versions/([" + "^/]+)" + ) + + def __init__(self, arm_id=None): + self.is_registry_id = None + if arm_id: + match = re.match(AMLVersionedArmId.REGEX_PATTERN, arm_id) + if match: + self.subscription_id = match.group(1) + self.resource_group_name = match.group(2) + self.workspace_name = match.group(3) + self.asset_type = match.group(4) + self.asset_name = match.group(5) + self.asset_version = match.group(6) + else: + match = re.match(REGISTRY_VERSION_PATTERN, arm_id) + if match: + self.asset_name = match.group(3) + self.asset_version = match.group(4) + self.is_registry_id = True + else: + msg = "Invalid AzureML ARM versioned Id {}" + raise ValidationException( + message=msg.format(arm_id), + no_personal_data_message=msg.format("[arm_id]"), + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.ARM_RESOURCE, + ) + + +def get_datastore_arm_id( + datastore_name: Optional[str] = None, operation_scope: Optional[OperationScope] = None +) -> Optional[str]: + return ( + DATASTORE_RESOURCE_ID.format( + operation_scope.subscription_id, + operation_scope.resource_group_name, + operation_scope.workspace_name, + datastore_name, + ) + if datastore_name + else None + ) + + +class AMLLabelledArmId(object): + """Parser for versioned arm id: e.g. /subscription/.../code/my- code/labels/default. + + :param arm_id: The labelled ARM id. + :type arm_id: str + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the ARM id is incorrectly formatted. + """ + + REGEX_PATTERN = ( + "^/?subscriptions/([^/]+)/resourceGroups/([" + "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)/labels/([" + "^/]+)" + ) + + def __init__(self, arm_id=None): + self.is_registry_id = None + if arm_id: + match = re.match(AMLLabelledArmId.REGEX_PATTERN, arm_id) + if match: + self.subscription_id = match.group(1) + self.resource_group_name = match.group(2) + self.workspace_name = match.group(3) + self.asset_type = match.group(4) + self.asset_name = match.group(5) + self.asset_label = match.group(6) + else: + match = re.match(REGISTRY_VERSION_PATTERN, arm_id) + if match: + self.asset_name = match.group(3) + self.asset_label = match.group(4) + self.is_registry_id = True + else: + msg = "Invalid AzureML ARM versioned Id {}" + raise ValidationException( + message=msg.format(arm_id), + no_personal_data_message=msg.format("[arm_id]"), + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.ARM_RESOURCE, + ) + + +class AMLNamedArmId: + """Parser for named arm id (no version): e.g. + + /subscription/.../compute/cpu-cluster. + + :param arm_id: The named ARM id. + :type arm_id: str + :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the ARM id is incorrectly formatted. + """ + + REGEX_PATTERN = ( + "^/?subscriptions/([^/]+)/resourceGroups/([" + "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)" + ) + + REGEX_PATTERN_WITH_PARENT = ( + "^/?subscriptions/([^/]+)/resourceGroups/([" + "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)/([^/]+)/([^/]+)" + ) + + def __init__(self, arm_id=None): + if arm_id: + match = re.match(AMLNamedArmId.REGEX_PATTERN_WITH_PARENT, arm_id) + if match: + self.asset_name = match.group(7) + self.asset_type = match.group(6) + self.parent_asset_name = match.group(5) + self.parent_azureml_type = match.group(4) + if match is None: + match = re.match(AMLNamedArmId.REGEX_PATTERN, arm_id) + if match: + self.asset_type = match.group(4) + self.asset_name = match.group(5) + self.parent_asset_name = None + self.parent_azureml_type = None + else: + msg = "Invalid AzureML ARM named Id {}" + raise ValidationException( + message=msg.format(arm_id), + no_personal_data_message=msg.format("[arm_id]"), + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.ARM_RESOURCE, + ) + + self.subscription_id = match.group(1) + self.resource_group_name = match.group(2) + self.workspace_name = match.group(3) + + +class AMLAssetId: + REGEX_PATTERN = ASSET_ID_URI_REGEX_FORMAT + + def __init__(self, asset_id: str): + """Parser for asset id. + + :param asset_id: The asset id. + :type asset_id: str + :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the asset id is incorrectly formatted. + """ + match = re.match(AMLAssetId.REGEX_PATTERN, asset_id) + if match is None: + msg = "Invalid AzureML Asset Id {}" + raise ValidationException( + message=msg.format(asset_id), + no_personal_data_message=msg.format("[asset_id]"), + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.ASSET, + ) + + self.location = match.group(1) + self.workspace_id = match.group(2) + self.asset_type = match.group(3) + self.asset_name = match.group(4) + self.asset_version = match.group(5) + + +class AzureResourceId: + """Parser for a non-AzureML ARM Id. + + :param arm_id: The non-AzureML ARM id. + :type arm_id: str + :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the ARM id is incorrectly formatted. + """ + + REGEX_PATTERN = "^/?subscriptions/([^/]+)/resourceGroups/([^/]+)/providers/Microsoft.([^/]+)/([^/]+)/([^/]+)" + RESOURCEGROUP_PATTERN = "^/?subscriptions/([^/]+)/providers/Microsoft.([^/]+)/([^/]+)/([^/]+)" + + def __init__(self, arm_id=None): + if arm_id: + match = re.match(AzureResourceId.REGEX_PATTERN, arm_id) + rg_match = re.match(AzureResourceId.RESOURCEGROUP_PATTERN, arm_id) + if match: + self.subscription_id = match.group(1) + self.resource_group_name = match.group(2) + self.provider_namespace_with_type = match.group(3) + match.group(4) + self.asset_type = match.group(4) + self.asset_name = match.group(5) + elif rg_match: + self.subscription_id = rg_match.group(1) + self.resource_group_name = None + self.asset_name = rg_match.group(4) + self.asset_type = rg_match.group(3) + else: + msg = "Invalid ARM Id {}" + raise ValidationException( + message=msg.format(arm_id), + no_personal_data_message=msg.format("[arm_id]"), + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.ARM_RESOURCE, + ) + + +class AzureStorageContainerResourceId: + """Parser for a Azure Storage Container ARM id. + + :param arm_id: The Azure Storage Container ARM id. + :type arm_id: str + :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the ARM id is incorrectly formatted. + """ + + REGEX_PATTERN = ( + "^/?subscriptions/([^/]+)/resourceGroups/([^/]+)/providers/Microsoft.Storage" + "/storageAccounts/([^/]+)/blobServices/default/containers/([^/]+)" + ) + + def __init__(self, arm_id=None): + if arm_id: + match = re.match(AzureStorageContainerResourceId.REGEX_PATTERN, arm_id) + if match: + self.subscription_id = match.group(1) + self.resource_group_name = match.group(2) + self.storage_account = match.group(3) + self.container = match.group(4) + else: + msg = "Invalid Azure Storage Container Resource Id {}" + raise ValidationException( + message=msg.format(arm_id), + no_personal_data_message=msg.format("[arm_id]"), + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.ARM_RESOURCE, + ) + + +def _parse_endpoint_name_from_deployment_id(deployment_id: str) -> str: + REGEX_PATTERN = ( + "^/?subscriptions/([^/]+)/resourceGroups/([" + "^/]+)/providers/Microsoft.MachineLearningServices/workspaces/([^/]+)/([^/]+)/([^/]+)/deployments/([^/]+)" + ) + match = re.match(REGEX_PATTERN, deployment_id) + if match is None: + msg = "Invalid Deployment Id {}" + raise ValidationException( + message=msg.format(deployment_id), + no_personal_data_message=msg.format("[id]"), + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.DEPLOYMENT, + ) + return match.group(5) + + +def parse_AzureML_id(name: str) -> Tuple[str, str, str]: + if name.startswith(ARM_ID_PREFIX): + name = name[len(ARM_ID_PREFIX) :] + + at_splits = name.rsplit("@", 1) + if len(at_splits) > 1: + return at_splits[0], None, name[1] + colon_splits = name.rsplit(":", 1) + return ( + colon_splits[0], + None if len(colon_splits) == 1 else colon_splits[1], + None, + ) + + +def parse_prefixed_name_version(name: str) -> Tuple[str, Optional[str]]: + if name.startswith(ARM_ID_PREFIX): + return parse_name_version(name[len(ARM_ID_PREFIX) :]) + return parse_name_version(name) + + +def parse_name_version(name: str) -> Tuple[str, Optional[str]]: + if name.find("/") != -1 and name[0] != "/": + raise ValidationException( + f"Could not parse {name}. If providing an ARM id, it should start with a '/'.", + no_personal_data_message=f"Could not parse {name}.", + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.ARM_RESOURCE, + ) + token_list = name.split(":") + if len(token_list) == 1: + return name, None + name, *version = token_list # type: ignore + return name, ":".join(version) + + +def parse_name_label(name: Optional[str]) -> Tuple[str, Optional[str]]: + if not name or (name.find("/") != -1 and name[0] != "/"): + raise ValidationException( + f"Could not parse {name}. If providing an ARM id, it should start with a '/'.", + no_personal_data_message=f"Could not parse {name}.", + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.ARM_RESOURCE, + ) + token_list = name.rpartition("@") + if not token_list[1]: # separator not found + *_, name = token_list + return name, None + name, _, label = token_list + return name, label + + +def is_ARM_id_for_resource(name: Any, resource_type: str = ".*", sub_workspace_resource: bool = True) -> bool: + if sub_workspace_resource: + resource_regex = NAMED_RESOURCE_ID_FORMAT.format( + ".*", ".*", AZUREML_RESOURCE_PROVIDER, ".*", resource_type, ".*" + ) + else: + resource_regex = LEVEL_ONE_NAMED_RESOURCE_ID_FORMAT.format( + ".*", ".*", AZUREML_RESOURCE_PROVIDER, resource_type, ".*" + ) + if isinstance(name, str) and re.match(resource_regex, name, re.IGNORECASE): + return True + return False + + +def is_ARM_id_for_parented_resource(name: str, parent_resource_type: str, child_resource_type: str) -> bool: + resource_regex = NAMED_RESOURCE_ID_FORMAT_WITH_PARENT.format( + ".*", + ".*", + AZUREML_RESOURCE_PROVIDER, + ".*", + parent_resource_type, + ".*", + child_resource_type, + "*", + ) + return re.match(resource_regex, name, re.IGNORECASE) is not None + + +def is_registry_id_for_resource(name: Any) -> bool: + if isinstance(name, str) and re.match(REGISTRY_URI_REGEX_FORMAT, name, re.IGNORECASE): + return True + return False + + +def is_singularity_id_for_resource(name: Any) -> bool: + if isinstance(name, str) and re.match(SINGULARITY_ID_REGEX_FORMAT, name, re.IGNORECASE): + return True + return False + + +def is_singularity_full_name_for_resource(name: Any) -> bool: + if isinstance(name, str) and (re.match(SINGULARITY_FULL_NAME_REGEX_FORMAT, name, re.IGNORECASE)): + return True + return False + + +def is_singularity_short_name_for_resource(name: Any) -> bool: + if isinstance(name, str) and re.match(SINGULARITY_SHORT_NAME_REGEX_FORMAT, name, re.IGNORECASE): + return True + return False + + +def get_arm_id_with_version( + operation_scope: OperationScope, + provider_name: str, + provider_value: str, + provider_version: str, +): + return PROVIDER_RESOURCE_ID_WITH_VERSION.format( + operation_scope.subscription_id, + operation_scope.resource_group_name, + operation_scope.workspace_name, + provider_name, + provider_value, + provider_version, + ) + + +def generate_data_arm_id(operation_scope: OperationScope, name: str, version: int): + return get_arm_id_with_version(operation_scope, DATA_ARM_TYPE, name, str(version)) + + +def remove_aml_prefix(resource_id: Optional[str]) -> Optional[str]: + if not resource_id: + return None + + if resource_id.startswith(ARM_ID_PREFIX): + return resource_id[len(ARM_ID_PREFIX) :] + return resource_id + + +def get_resource_name_from_arm_id(resource_id: str) -> str: + # parse arm id to datastore name + return AMLNamedArmId(resource_id).asset_name + + +def get_resource_name_from_arm_id_safe(resource_id: str) -> str: + """Get the resource name from an ARM id. + + :param resource_id: The resource's ARM ID + :type resource_id: str + :return: + * Resource Name if input string is ARM id + * Original input otherwise + :rtype: str + """ + try: + return get_resource_name_from_arm_id(resource_id) + except ValidationException: + # already a name + return resource_id + except AttributeError: + # None or empty string + return resource_id + except Exception: # pylint: disable=W0718 + # unexpected error + module_logger.warning("Failed to parse resource id: %s", resource_id) + return resource_id + + +def get_arm_id_object_from_id( + resource_id: str, +) -> Union[AMLVersionedArmId, AMLNamedArmId, AzureResourceId]: + """Attempts to create and return one of: AMLVersionedId, AMLNamedId, AzureResoureId. In the case than an AzureML ARM + Id is passed in, either AMLVersionedId or AMLNamedId will be created depending on resource type In the case that a + non-AzureML ARM id is passed in, an AzureResourceId will be returned. + + :param resource_id: the ARM Id to parse + :type resource_id: str + :raises ~azure.ai.ml.exceptions.ValidationException~: Raised if the ARM id is incorrectly formatted. + :return: The parser for the given ARM Id + :rtype: Union[AMLVersionedArmId, AMLNamedArmId, AzureResourceId] + """ + + # Try each type of parser for the ARM id. If none succeed, raise a ValueError + try: + return AMLVersionedArmId(resource_id) + except ValidationException: + pass + + try: + return AMLNamedArmId(resource_id) + except ValidationException: + pass + + try: + return AzureResourceId(resource_id) + except ValidationException: + pass + + msg = "Invalid ARM Id {}" + raise ValidationException( + message=msg.format(resource_id), + no_personal_data_message=msg.format("[resource_id]"), + error_type=ValidationErrorType.INVALID_VALUE, + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.DEPLOYMENT, + ) + + +def remove_datastore_prefix(datastore_id: Optional[str]) -> Optional[str]: + if not datastore_id: + return None + + if datastore_id.startswith(DATASTORE_SHORT_URI): + return datastore_id[len(DATASTORE_SHORT_URI) :] + return datastore_id diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_artifact_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_artifact_utils.py new file mode 100644 index 00000000..9dafaf79 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_artifact_utils.py @@ -0,0 +1,454 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- +import copy +import hashlib +import logging +import os +import re +import shutil +import subprocess +import tempfile +import zipfile +from collections import defaultdict +from io import BytesIO +from pathlib import Path +from threading import Lock +from typing import Iterable, List, Optional, Union + +from typing_extensions import Literal + +from azure.ai.ml.constants._common import DefaultOpenEncoding + +from ._http_utils import HttpPipeline +from .utils import get_base_directory_for_cache + +_logger = logging.getLogger(__name__) + + +class ArtifactCache: + """Disk cache of azure artifact packages. + + The key of the cache is path of artifact packages in local, like this + azure-ai-ml/components/additional_includes/artifacts/{organization}/{project}/{feed}/{package_name}/{version}. + The value is the files/folders in this cache folder. + """ + + # artifact cache is shared across SDK versions and across workspaces/registries + DEFAULT_DISK_CACHE_DIRECTORY = get_base_directory_for_cache().joinpath( + "components", + "additional_includes", + "artifacts", + ) + POSTFIX_CHECKSUM = "checksum" + _instance_lock = Lock() + _instance = None + + def __new__(cls): + """Singleton creation disk cache.""" + if cls._instance is None: + with cls._instance_lock: + if cls._instance is None: + cls._instance = object.__new__(cls) + cls.check_artifact_extension() + return cls._instance + + @staticmethod + def check_artifact_extension(): + # check az extension azure-devops installed. Install it if not installed. + result = subprocess.run( + [shutil.which("az"), "artifacts", "--help", "--yes"], + capture_output=True, + check=False, + ) + + if result.returncode != 0: + raise RuntimeError( + "Auto-installation failed. Please install azure-devops " + "extension by 'az extension add --name azure-devops'." + ) + + def __init__(self, cache_directory=None): + self._cache_directory = cache_directory or self.DEFAULT_DISK_CACHE_DIRECTORY + Path(self._cache_directory).mkdir(exist_ok=True, parents=True) + self._artifacts_tool_path = None + self._download_locks = defaultdict(Lock) + + @property + def cache_directory(self) -> Path: + """Cache directory path. + + :return: The cache directory + :rtype: Path + """ + return self._cache_directory + + @staticmethod + def hash_files_content(file_list: List[Union[str, os.PathLike]]) -> str: + """Hash the file content in the file list. + + :param file_list: The list of files to hash + :type file_list: List[Union[str, os.PathLike]] + :return: Hashed file contents + :rtype: str + """ + ordered_file_list = copy.copy(file_list) + hasher = hashlib.sha256() + ordered_file_list.sort() + for item in ordered_file_list: + with open(item, "rb") as f: + hasher.update(f.read()) + return hasher.hexdigest() + + @staticmethod + def _format_organization_name(organization): + pattern = r'[<>:"\\/|?*]' + normalized_organization_name = re.sub(pattern, "_", organization) + return normalized_organization_name + + @staticmethod + def get_organization_project_by_git(): + """Get organization and project from git remote url. For example, the git remote url is + "https://organization.visualstudio.com/xxx/project_name/_git/repositry_name" or + "https://dev.azure.com/{organization}/project". + + :return organization_url, project: organization_url, project + :rtype organization_url, project: str, str + """ + result = subprocess.run( + [shutil.which("git"), "config", "--get", "remote.origin.url"], + capture_output=True, + encoding="utf-8", + check=False, + ) + + if result.returncode != 0: + # When organization and project cannot be retrieved from the origin url. + raise RuntimeError( + f"Get the git origin url failed, you must be in a local Git directory, " + f"error message: {result.stderr}" + ) + origin_url = result.stdout.strip() + + # Organization URL has two format, https://dev.azure.com/{organization} and + # https://{organization}.visualstudio.com + # https://learn.microsoft.com/azure/devops/extend/develop/work-with-urls?view=azure-devops&tabs=http + if "dev.azure.com" in origin_url: + regex = r"^https:\/\/\w*@?dev\.azure\.com\/(\w*)\/(\w*)" + results = re.findall(regex, origin_url) + if results: + organization, project = results[0] + return f"https://dev.azure.com/{organization}", project + elif "visualstudio.com" in origin_url: + regex = r"https:\/\/(\w*)\.visualstudio\.com.*\/(\w*)\/_git" + results = re.findall(regex, origin_url) + if results: + organization, project = results[0] + return f"https://{organization}.visualstudio.com", project + + # When organization and project cannot be retrieved from the origin url. + raise RuntimeError( + f'Cannot get organization and project from git origin url "{origin_url}", ' + f'you must be in a local Git directory that has a "remote" referencing a ' + f"Azure DevOps or Azure DevOps Server repository." + ) + + @classmethod + def _get_checksum_path(cls, path): + artifact_path = Path(path) + return artifact_path.parent / f"{artifact_path.name}_{cls.POSTFIX_CHECKSUM}" + + def _redirect_artifacts_tool_path(self, organization: Optional[str]): + """Downloads the artifacts tool and redirects `az artifact` command to it. + + Done to avoid the transient issue when download artifacts + + :param organization: The organization url. If None, is determined by local git repo + :type organization: Optional[str] + """ + from azure.identity import DefaultAzureCredential + + if not organization: + organization, _ = self.get_organization_project_by_git() + + organization_pattern = r"https:\/\/(.*)\.visualstudio\.com" + result = re.findall(pattern=organization_pattern, string=organization) + if result: + organization_name = result[0] + else: + organization_pattern = r"https:\/\/dev\.azure\.com\/(.*)" + result = re.findall(pattern=organization_pattern, string=organization) + if not result: + raise RuntimeError("Cannot find artifact organization.") + organization_name = result[0] + + if not self._artifacts_tool_path: + os_name = "Windows" if os.name == "nt" else "Linux" + credential = DefaultAzureCredential() + token = credential.get_token("https://management.azure.com/.default") + header = {"Authorization": "Bearer " + token.token} + + # The underlying HttpTransport is meant to be user configurable. + # MLClient instances have a user configured Pipeline for sending http requests + # TODO: Replace this with MlCLient._requests_pipeline + requests_pipeline = HttpPipeline() + url = ( + f"https://{organization_name}.vsblob.visualstudio.com/_apis/clienttools/ArtifactTool/release?" + f"osName={os_name}&arch=AMD64" + ) + response = requests_pipeline.get( # pylint: disable=too-many-function-args,unexpected-keyword-arg + url, headers=header + ) + if response.status_code == 200: + artifacts_tool_path = tempfile.mkdtemp() # nosec B306 + artifacts_tool_uri = response.json()["uri"] + response = requests_pipeline.get(artifacts_tool_uri) # pylint: disable=too-many-function-args + with zipfile.ZipFile(BytesIO(response.content)) as zip_file: + zip_file.extractall(artifacts_tool_path) + os.environ["AZURE_DEVOPS_EXT_ARTIFACTTOOL_OVERRIDE_PATH"] = str(artifacts_tool_path.resolve()) + self._artifacts_tool_path = artifacts_tool_path + else: + _logger.warning("Download artifact tool failed: %s", response.text) + + def _download_artifacts( + self, + download_cmd: Iterable[str], + organization: Optional[str], + name: str, + version: str, + feed: str, + max_retries: int = 3, + ): + """Download artifacts with retry. + + :param download_cmd: The command used to download the artifact + :type download_cmd: Iterable[str] + :param organization: The artifact organization + :type organization: Optional[str] + :param name: The package name + :type name: str + :param version: The package version + :type version: str + :param feed: The download feed + :type feed: str + :param max_retries: The number of times to retry the download. Defaults to 3 + :type max_retries: int + """ + retries = 0 + while retries <= max_retries: + try: + self._redirect_artifacts_tool_path(organization) + except Exception as e: # pylint: disable=W0718 + _logger.warning("Redirect artifacts tool path failed, details: %s", e) + + retries += 1 + result = subprocess.run( + download_cmd, + capture_output=True, + encoding="utf-8", + check=False, + ) + + if result.returncode != 0: + error_msg = ( + f"Download package {name}:{version} from the feed {feed} failed {retries} times: {result.stderr}" + ) + if retries < max_retries: + _logger.warning(error_msg) + else: + error_msg = error_msg + f"\nDownload artifact debug info: {result.stdout}" + raise RuntimeError(error_msg) + else: + return + + def _check_artifacts(self, artifact_package_path: Union[str, os.PathLike]) -> bool: + """Check the artifact folder is legal. + + :param artifact_package_path: The artifact package path + :type artifact_package_path: Union[str, os.PathLike] + :return: + * If the artifact folder or checksum file does not exist, return false. + * If the checksum file exists and does not equal to the hash of artifact folder, return False. + * If the checksum file equals to the hash of artifact folder, return true. + :rtype: bool + """ + path = Path(artifact_package_path) + if not path.exists(): + return False + checksum_path = self._get_checksum_path(artifact_package_path) + if checksum_path.exists(): + with open(checksum_path, "r", encoding=DefaultOpenEncoding.READ) as f: + checksum = f.read() + file_list = [os.path.join(root, f) for root, _, files in os.walk(path) for f in files] + artifact_hash = self.hash_files_content(file_list) + return checksum == artifact_hash + return False + + def get( + self, + feed: str, + name: str, + version: str, + scope: Literal["project", "organization"], + organization: Optional[str] = None, + project: Optional[str] = None, + resolve: bool = True, + ) -> Optional[Path]: + """Get the catch path of artifact package. Package path like this azure-ai- + ml/components/additional_includes/artifacts/{organization}/{project}/{feed}/{package_name}/{version}. If the + path exits, it will return the package path. If the path not exist and resolve=True, it will download the + artifact package and return package path. If the path not exist and resolve=False, it will return None. + + :param feed: Name or ID of the feed. + :type feed: str + :param name: Name of the package. + :type name: str + :param version: Version of the package. + :type version: str + :param scope: Scope of the feed: 'project' if the feed was created in a project, and 'organization' otherwise. + :type scope: Literal["project", "organization"] + :param organization: Azure DevOps organization URL. + :type organization: str + :param project: Name or ID of the project. + :type project: str + :param resolve: Whether download package when package does not exist in local. + :type resolve: bool + :return artifact_package_path: Cache path of the artifact package + :rtype: Optional[Path] + """ + if not all([organization, project]): + org_val, project_val = self.get_organization_project_by_git() + organization = organization or org_val + project = project or project_val + artifact_package_path = ( + Path(self.DEFAULT_DISK_CACHE_DIRECTORY) + / self._format_organization_name(organization) + / project + / feed + / name + / version + ) + # Use lock to avoid downloading the same package at the same time. + with self._download_locks[artifact_package_path]: + if self._check_artifacts(artifact_package_path): + # When the cache folder of artifact package exists, it's sure that the package has been downloaded. + return artifact_package_path.absolute().resolve() + if resolve: + check_sum_path = self._get_checksum_path(artifact_package_path) + if Path(check_sum_path).exists(): + os.unlink(check_sum_path) + if artifact_package_path.exists(): + # Remove invalid artifact package to avoid affecting download artifact. + temp_folder = tempfile.mkdtemp() # nosec B306 + os.rename(artifact_package_path, temp_folder) + shutil.rmtree(temp_folder) + # Download artifact + return self.set( + feed=feed, + name=name, + version=version, + organization=organization, + project=project, + scope=scope, + ) + return None + + def set( + self, + feed: str, + name: str, + version: str, + scope: Literal["project", "organization"], + organization: Optional[str] = None, + project: Optional[str] = None, + ) -> Path: + """Set the artifact package to the cache. The key of the cache is path of artifact packages in local. The value + is the files/folders in this cache folder. If package path exists, directly return package path. + + :param feed: Name or ID of the feed. + :type feed: str + :param name: Name of the package. + :type name: str + :param version: Version of the package. + :type version: str + :param scope: Scope of the feed: 'project' if the feed was created in a project, and 'organization' otherwise. + :type scope: Literal["project", "organization"] + :param organization: Azure DevOps organization URL. + :type organization: str + :param project: Name or ID of the project. + :type project: str + :return artifact_package_path: Cache path of the artifact package + :rtype: Path + """ + tempdir = tempfile.mkdtemp() # nosec B306 + download_cmd = [ + shutil.which("az"), + "artifacts", + "universal", + "download", + "--feed", + feed, + "--name", + name, + "--version", + version, + "--scope", + scope, + "--path", + tempdir, + ] + if organization: + download_cmd.extend(["--org", organization]) + if project: + download_cmd.extend(["--project", project]) + _logger.info("Start downloading artifacts %s:%s from %s.", name, version, feed) + result = subprocess.run( + download_cmd, + capture_output=True, + encoding="utf-8", + check=False, + ) + + if result.returncode != 0: + artifacts_tool_not_find_error_pattern = "No such file or directory: .*artifacttool" + if re.findall(artifacts_tool_not_find_error_pattern, result.stderr): + # When download artifacts tool failed retry download artifacts command + _logger.warning( + "Download package %s:%s from the feed %s failed: %s", name, version, feed, result.stderr + ) + download_cmd.append("--debug") + self._download_artifacts(download_cmd, organization, name, version, feed) + else: + raise RuntimeError(f"Download package {name}:{version} from the feed {feed} failed: {result.stderr}") + try: + # Copy artifact package from temp folder to the cache path. + if not all([organization, project]): + org_val, project_val = self.get_organization_project_by_git() + organization = organization or org_val + project = project or project_val + artifact_package_path = ( + Path(self.DEFAULT_DISK_CACHE_DIRECTORY) + / self._format_organization_name(organization) + / project + / feed + / name + / version + ) + artifact_package_path.parent.mkdir(exist_ok=True, parents=True) + file_list = [os.path.join(root, f) for root, _, files in os.walk(tempdir) for f in files] + artifact_hash = self.hash_files_content(file_list) + os.rename(tempdir, artifact_package_path) + temp_checksum_file = os.path.join(tempfile.mkdtemp(), f"{version}_{self.POSTFIX_CHECKSUM}") + with open(temp_checksum_file, "w", encoding=DefaultOpenEncoding.WRITE) as f: + f.write(artifact_hash) + os.rename( + temp_checksum_file, + artifact_package_path.parent / f"{version}_{self.POSTFIX_CHECKSUM}", + ) + except (FileExistsError, PermissionError, OSError): + # On Windows, if dst exists a FileExistsError is always raised. + # On Unix, if dst is a non-empty directory, an OSError is raised. + # If dst is being used by another process will raise PermissionError. + # https://docs.python.org/3/library/os.html#os.rename + pass + return artifact_package_path.absolute().resolve() diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_asset_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_asset_utils.py new file mode 100644 index 00000000..7081d9d6 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_asset_utils.py @@ -0,0 +1,1224 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +# pylint: disable=protected-access,too-many-lines + +import hashlib +import logging +import os +import json +import uuid +import warnings +from concurrent.futures import ThreadPoolExecutor, as_completed +from contextlib import suppress +from multiprocessing import cpu_count +from os import PathLike +from pathlib import Path +from platform import system +from typing import ( + TYPE_CHECKING, + Any, + Dict, + Iterable, + List, + Optional, + Tuple, + Union, + cast, +) + +from colorama import Fore +from tqdm import TqdmWarning, tqdm +from typing_extensions import Literal + +from azure.ai.ml._artifacts._constants import ( + AML_IGNORE_FILE_NAME, + ARTIFACT_ORIGIN, + AUTO_DELETE_SETTING_NOT_ALLOWED_ERROR_NO_PERSONAL_DATA, + BLOB_STORAGE_CLIENT_NAME, + CHUNK_SIZE, + DEFAULT_CONNECTION_TIMEOUT, + EMPTY_DIRECTORY_ERROR, + GEN2_STORAGE_CLIENT_NAME, + GIT_IGNORE_FILE_NAME, + INVALID_MANAGED_DATASTORE_PATH_ERROR_NO_PERSONAL_DATA, + MAX_CONCURRENCY, + PROCESSES_PER_CORE, + UPLOAD_CONFIRMATION, + WORKSPACE_MANAGED_DATASTORE, + WORKSPACE_MANAGED_DATASTORE_WITH_SLASH, +) +from azure.ai.ml._restclient.v2022_02_01_preview.operations import ( + ComponentContainersOperations, + ComponentVersionsOperations, + DataContainersOperations, + DataVersionsOperations, + EnvironmentContainersOperations, + EnvironmentVersionsOperations, + ModelContainersOperations, + ModelVersionsOperations, +) +from azure.ai.ml._restclient.v2022_05_01.models import ( + DataVersionBaseData, + ModelVersionData, + ModelVersionResourceArmPaginatedResult, +) +from azure.ai.ml._restclient.v2023_04_01.models import PendingUploadRequestDto +from azure.ai.ml._utils._pathspec import GitWildMatchPattern, normalize_file +from azure.ai.ml._utils.utils import convert_windows_path_to_unix, retry, snake_to_camel +from azure.ai.ml.constants._common import ( + MAX_AUTOINCREMENT_ATTEMPTS, + DefaultOpenEncoding, + OrderString, +) +from azure.ai.ml.entities._assets.asset import Asset +from azure.ai.ml.exceptions import ( + AssetPathException, + EmptyDirectoryError, + ErrorCategory, + ErrorTarget, + ValidationErrorType, + ValidationException, +) +from azure.core.exceptions import ResourceExistsError, ResourceNotFoundError + +if TYPE_CHECKING: + from azure.ai.ml.operations import ( + ComponentOperations, + DataOperations, + EnvironmentOperations, + IndexOperations, + ModelOperations, + ) + +hash_type = type(hashlib.md5()) # nosec + +module_logger = logging.getLogger(__name__) + + +class AssetNotChangedError(Exception): + pass + + +class IgnoreFile(object): + def __init__(self, file_path: Optional[Union[str, os.PathLike]] = None): + """Base class for handling .gitignore and .amlignore files. + + :param file_path: Relative path, or absolute path to the ignore file. + """ + path = Path(file_path).resolve() if file_path else None + self._path = path + self._path_spec = None + + def exists(self) -> bool: + """Checks if ignore file exists. + :return: True if file exists. False Otherwise + :rtype: bool + """ + return self._file_exists() + + def _file_exists(self) -> bool: + return self._path and self._path.exists() + + @property + def base_path(self) -> Path: + return self._path.parent + + def _get_ignore_list(self) -> List[str]: + """Get ignore list from ignore file contents. + + :return: The lines of the ignore file + :rtype: List[str] + """ + if not self.exists(): + return [] + if self._file_exists(): + with open(self._path, "r", encoding=DefaultOpenEncoding.READ) as fh: + return [line.rstrip() for line in fh if line] + return [] + + def _create_pathspec(self) -> List[GitWildMatchPattern]: + """Creates path specification based on ignore list. + + :return: Path specification + :rtype: List[GitWildMatchPattern] + """ + return [GitWildMatchPattern(ignore) for ignore in self._get_ignore_list()] + + def _get_rel_path(self, file_path: Union[str, os.PathLike]) -> Optional[str]: + """Get relative path of given file_path. + + :param file_path: A file path + :type file_path: Union[str, os.PathLike] + :return: file_path relative to base_path, if computable. None otherwise + :rtype: Optional[str] + """ + file_path = Path(file_path).absolute() + try: + # use os.path.relpath instead of Path.relative_to in case file_path is not a child of self.base_path + return os.path.relpath(file_path, self.base_path) + except ValueError: + # 2 paths are on different drives + return None + + def is_file_excluded(self, file_path: Union[str, os.PathLike]) -> bool: + """Checks if given file_path is excluded. + + :param file_path: File path to be checked against ignore file specifications + :type file_path: Union[str, os.PathLike] + :return: Whether the file is excluded by ignore file + :rtype: bool + """ + # TODO: current design of ignore file can't distinguish between files and directories of the same name + if self._path_spec is None: + self._path_spec = self._create_pathspec() + if not self._path_spec: + return False + file_path = self._get_rel_path(file_path) + if file_path is None: + return True + + norm_file = normalize_file(file_path) + matched = False + for pattern in self._path_spec: + if pattern.include is not None: + if pattern.match_file(norm_file) is not None: + matched = pattern.include + + return matched + + @property + def path(self) -> Union[Path, str]: + return self._path + + +class AmlIgnoreFile(IgnoreFile): + def __init__(self, directory_path: Union[Path, str]): + file_path = Path(directory_path).joinpath(AML_IGNORE_FILE_NAME) + super(AmlIgnoreFile, self).__init__(file_path) + + +class GitIgnoreFile(IgnoreFile): + def __init__(self, directory_path: Union[Path, str]): + file_path = Path(directory_path).joinpath(GIT_IGNORE_FILE_NAME) + super(GitIgnoreFile, self).__init__(file_path) + + +def get_ignore_file(directory_path: Union[Path, str]) -> IgnoreFile: + """Finds and returns IgnoreFile object based on ignore file found in directory_path. + + .amlignore takes precedence over .gitignore and if no file is found, an empty + IgnoreFile object will be returned. + + The ignore file must be in the root directory. + + :param directory_path: Path to the (root) directory where ignore file is located + :type directory_path: Union[Path, str] + :return: The IgnoreFile found in the directory + :rtype: IgnoreFile + """ + aml_ignore = AmlIgnoreFile(directory_path) + git_ignore = GitIgnoreFile(directory_path) + + if aml_ignore.exists(): + return aml_ignore + if git_ignore.exists(): + return git_ignore + return IgnoreFile() + + +def _validate_path(path: Union[str, os.PathLike], _type: str) -> None: + path = Path(path) # Okay to do this since Path is idempotent + if not path.is_file() and not path.is_dir(): + raise ValidationException( + message=f"No such file or directory: {path}", + target=_type, + error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND, + no_personal_data_message="No such file or directory", + error_category=ErrorCategory.USER_ERROR, + ) + + +def _parse_name_version( + name: Optional[str] = None, version_as_int: bool = True +) -> Tuple[Optional[str], Optional[Union[str, int]]]: + if not name: + return None, None + + token_list = name.split(":") + if len(token_list) == 1: + return name, None + *name, version = token_list + if version_as_int: + version = int(version) + return ":".join(name), version + + +def _get_file_hash(filename: Union[str, os.PathLike], _hash: hash_type) -> hash_type: + with open(str(filename), "rb") as f: + for chunk in iter(lambda: f.read(CHUNK_SIZE), b""): + _hash.update(chunk) + return _hash + + +def delete_two_catalog_files(path): + """ + Function that deletes the "catalog.json" and "catalog.json.sig" files located at 'path', if they exist + + :param path: Path to the folder for signing + :type path: Union[Path, str] + :return: None + """ + # catalog.json + file_path_json = os.path.join(path, "catalog.json") + if os.path.exists(file_path_json): + module_logger.warning("%s already exists. Deleting it", file_path_json) + os.remove(file_path_json) + # catalog.json.sig + file_path_json_sig = os.path.join(path, "catalog.json.sig") + if os.path.exists(file_path_json_sig): + module_logger.warning("%s already exists. Deleting it", file_path_json_sig) + os.remove(file_path_json_sig) + + +def create_catalog_files(path, json_stub): + with open(os.path.join(path, "catalog.json"), "w", encoding=DefaultOpenEncoding.WRITE) as jsonFile1: + json.dump(json_stub, jsonFile1) + with open(os.path.join(path, "catalog.json.sig"), "w", encoding=DefaultOpenEncoding.WRITE) as jsonFile2: + json.dump(json_stub, jsonFile2) + + +def _get_dir_hash(directory: Union[str, os.PathLike], _hash: hash_type, ignore_file: IgnoreFile) -> hash_type: + dir_contents = Path(directory).iterdir() + sorted_contents = sorted(dir_contents, key=lambda path: str(path).lower()) + for path in sorted_contents: + if ignore_file.is_file_excluded(path): + continue + _hash.update(path.name.encode()) + if os.path.islink(path): # ensure we're hashing the contents of the linked file + path = _resolve_path(path) + if path.is_file(): + _hash = _get_file_hash(path, _hash) + elif path.is_dir(): + _hash = _get_dir_hash(path, _hash, ignore_file) + return _hash + + +def _build_metadata_dict(name: str, version: str) -> Dict[str, str]: + """Build metadata dictionary to attach to uploaded data. + + Metadata includes an upload confirmation field, and for code uploads only, the name and version of the code asset + being created for that data. + + :param name: The name of the uploaded data + :type name: str + :param version: The version of the uploaded data + :type version: str + :return: Metadata dict + :rtype: Dict[str, str] + """ + if name: + linked_asset_arm_id = {"name": name, "version": version} + else: + msg = "'name' cannot be NoneType for asset artifact upload." + raise ValidationException( + message=msg, + no_personal_data_message=msg, + target=ErrorTarget.ASSET, + error_category=ErrorCategory.USER_ERROR, + error_type=ValidationErrorType.INVALID_VALUE, + ) + + metadata_dict = {**UPLOAD_CONFIRMATION, **linked_asset_arm_id} + return metadata_dict + + +def get_object_hash(path: Union[str, os.PathLike], ignore_file: IgnoreFile = IgnoreFile()) -> str: + _hash = hashlib.md5(b"Initialize for october 2021 AML CLI version") # nosec + if Path(path).is_dir(): + object_hash = _get_dir_hash(directory=path, _hash=_hash, ignore_file=ignore_file) + else: + if os.path.islink(path): # ensure we're hashing the contents of the linked file + path = _resolve_path(Path(path)) + object_hash = _get_file_hash(filename=path, _hash=_hash) + return str(object_hash.hexdigest()) + + +def get_content_hash_version(): + return 202208 + + +def get_content_hash(path: Union[str, os.PathLike], ignore_file: IgnoreFile = IgnoreFile()) -> Optional[str]: + """Generating sha256 hash for file/folder, + + e.g. Code snapshot fingerprints to prevent tampering. + + The process of hashing is: + 1. If it's a link, get the actual path of the link. + 2. If it's a file, append file content. + 3. If it's a folder: + 1. list all files under the folder + 2. convert file count to str and append to hash + 3. sort the files by lower case of relative path + 4. for each file append '#'+relative path+'#' and file size to hash + 5. do another iteration on file list to append each files content to hash. + The example of absolute path to relative path mapping is: + [ + ('/mnt/c/codehash/code/file1.txt', 'file1.txt'), + ('/mnt/c/codehash/code/folder1/file1.txt', 'folder1/file1.txt'), + ('/mnt/c/codehash/code/Folder2/file1.txt', 'Folder2/file1.txt'), + ('/mnt/c/codehash/code/Folder2/folder1/file1.txt', 'Folder2/folder1/file1.txt') + ] + 4. Hash the content and convert to hex digest string. + + :param path: The directory to calculate the size of + :type path: Union[str, os.PathLike] + :param ignore_file: An ignore file that specifies files to ignore when computing the size + :type ignore_file: IgnoreFile + :return: The content hash if the content is a link, directory, or file. None otherwise + :rtype: Optional[str] + """ + # DO NOT change this function unless you change the verification logic together + actual_path = path + if os.path.islink(path): + actual_path = _resolve_path(Path(path)).as_posix() + if os.path.isdir(actual_path): + return _get_file_list_content_hash(get_upload_files_from_folder(actual_path, ignore_file=ignore_file)) + if os.path.isfile(actual_path): + return _get_file_list_content_hash([(actual_path, Path(actual_path).name)]) + return None + + +def get_upload_files_from_folder( + path: Union[str, os.PathLike], + *, + prefix: str = "", + ignore_file: IgnoreFile = IgnoreFile(), +) -> List[str]: + path = Path(path) + upload_paths = [] + for root, _, files in os.walk(path, followlinks=True): + upload_paths += list( + traverse_directory( + root, + files, + prefix=Path(prefix).joinpath(Path(root).relative_to(path)).as_posix(), + ignore_file=ignore_file, + ) + ) + return upload_paths + + +def _get_file_list_content_hash(file_list) -> str: + # file_list is a list of tuples, (absolute_path, relative_path) + + _hash = hashlib.sha256() + # Add file count to the hash and add '#' around file name then add each file's size to avoid collision like: + # Case 1: + # 'a.txt' with contents 'a' + # 'b.txt' with contents 'b' + # + # Case 2: + # cspell:disable-next-line + # 'a.txt' with contents 'ab.txtb' + _hash.update(str(len(file_list)).encode()) + # Sort by "destination" path, since in this function destination prefix is empty and keep the link name in path. + for file_path, file_name in sorted(file_list, key=lambda x: str(x[1]).lower()): + _hash.update(("#" + file_name + "#").encode()) + _hash.update(str(os.path.getsize(file_path)).encode()) + for file_path, file_name in sorted(file_list, key=lambda x: str(x[1]).lower()): + _hash = _get_file_hash(file_path, _hash) + return str(_hash.hexdigest()) + + +def traverse_directory( # pylint: disable=unused-argument + root: str, + files: List[str], + *, + prefix: str, + ignore_file: IgnoreFile = IgnoreFile(), + # keep this for backward compatibility + **kwargs: Any, +) -> Iterable[Tuple[str, Union[str, Any]]]: + """Enumerate all files in the given directory and compose paths for them to be uploaded to in the remote storage. + e.g. + + [/mnt/c/Users/dipeck/upload_files/my_file1.txt, + /mnt/c/Users/dipeck/upload_files/my_file2.txt] --> + + [(/mnt/c/Users/dipeck/upload_files/my_file1.txt, LocalUpload/<guid>/upload_files/my_file1.txt), + (/mnt/c/Users/dipeck/upload_files/my_file2.txt, LocalUpload/<guid>/upload_files/my_file2.txt))] + + :param root: Root directory path + :type root: str + :param files: List of all file paths in the directory + :type files: List[str] + :keyword prefix: Remote upload path for project directory (e.g. LocalUpload/<guid>/project_dir) + :paramtype prefix: str + :keyword ignore_file: The .amlignore or .gitignore file in the project directory + :paramtype ignore_file: azure.ai.ml._utils._asset_utils.IgnoreFile + :return: Zipped list of tuples representing the local path and remote destination path for each file + :rtype: Iterable[Tuple[str, Union[str, Any]]] + """ + # Normalize Windows paths. Note that path should be resolved first as long part will be converted to a shortcut in + # Windows. For example, C:\Users\too-long-user-name\test will be converted to C:\Users\too-lo~1\test by default. + # Refer to https://en.wikipedia.org/wiki/8.3_filename for more details. + root = Path(root).resolve().absolute() + + # filter out files excluded by the ignore file + # TODO: inner ignore file won't take effect. A merged IgnoreFile need to be generated in code resolution. + origin_file_paths = [ + root.joinpath(filename) + for filename in files + if not ignore_file.is_file_excluded(root.joinpath(filename).as_posix()) + ] + + result = [] + for origin_file_path in origin_file_paths: + relative_path = origin_file_path.relative_to(root) + result.append( + ( + _resolve_path(origin_file_path).as_posix(), + Path(prefix).joinpath(relative_path).as_posix(), + ) + ) + return result + + +def _resolve_path(path: Path) -> Path: + if not path.is_symlink(): + return path + + link_path = path.resolve() + if not link_path.is_absolute(): + link_path = path.parent.joinpath(link_path).resolve() + return _resolve_path(link_path) + + +def generate_asset_id(asset_hash: str, include_directory=True) -> str: + asset_id = asset_hash or str(uuid.uuid4()) + if include_directory: + asset_id = "/".join((ARTIFACT_ORIGIN, asset_id)) + return asset_id + + +def get_directory_size( + root: Union[str, os.PathLike], ignore_file: IgnoreFile = IgnoreFile(None) +) -> Tuple[int, Dict[str, int]]: + """Returns total size of a directory and a dictionary itemizing each sub- path and its size. + + If an optional ignore_file argument is provided, then files specified in the ignore file are not included in the + directory size calculation. + + :param root: The directory to calculate the size of + :type root: Union[str, os.PathLike] + :param ignore_file: An ignore file that specifies files to ignore when computing the size + :type ignore_file: IgnoreFile + :return: The computed size of the directory, and the sizes of the child paths + :rtype: Tuple[int, Dict[str, int]] + """ + total_size = 0 + size_list = {} + for dirpath, _, filenames in os.walk(root, followlinks=True): + for name in filenames: + full_path = os.path.join(dirpath, name) + # Don't count files that are excluded by an ignore file + if ignore_file.is_file_excluded(full_path): + continue + if not os.path.islink(full_path): + path_size = os.path.getsize(full_path) + else: + # ensure we're counting the size of the linked file + # os.readlink returns a file path relative to dirpath, and must be + # re-joined to get a workable result + path_size = os.path.getsize(os.path.join(dirpath, os.readlink(convert_windows_path_to_unix(full_path)))) + size_list[full_path] = path_size + total_size += path_size + return total_size, size_list + + +def upload_file( + storage_client: Union["BlobStorageClient", "Gen2StorageClient"], + source: str, + dest: Optional[str] = None, + msg: Optional[str] = None, + size: int = 0, + show_progress: Optional[bool] = None, + in_directory: bool = False, + callback: Optional[Any] = None, +) -> None: + """Upload a single file to remote storage. + + :param storage_client: Storage client object + :type storage_client: Union[ + azure.ai.ml._artifacts._blob_storage_helper.BlobStorageClient, + azure.ai.ml._artifacts._gen2_storage_helper.Gen2StorageClient] + :param source: Local path to project directory + :type source: str + :param dest: Remote upload path for project directory (e.g. LocalUpload/<guid>/project_dir) + :type dest: str + :param msg: Message to be shown with progress bar (e.g. "Uploading <source>") + :type msg: str + :param size: Size of the file in bytes + :type size: int + :param show_progress: Whether to show progress bar or not + :type show_progress: bool + :param in_directory: Whether the file is part of a directory of files + :type in_directory: bool + :param callback: Callback to progress bar + :type callback: Any + :return: None + """ + validate_content = size > 0 # don't do checksum for empty files + + if ( + type(storage_client).__name__ == GEN2_STORAGE_CLIENT_NAME + ): # Only for Gen2StorageClient, Blob Storage doesn't have true directories + if in_directory: + storage_client.temp_sub_directory_client = None + file_name_tail = dest.split(os.path.sep)[-1] + # Indexing from 2 because the first two parts of the remote path will always be LocalUpload/<asset_id> + all_sub_folders = dest.split(os.path.sep)[2:-1] + + # Create remote directories for each nested directory if file is in a nested directory + for sub_folder in all_sub_folders: + if storage_client.temp_sub_directory_client: + storage_client.temp_sub_directory_client = ( + storage_client.temp_sub_directory_client.create_sub_directory(sub_folder) + ) + else: + storage_client.temp_sub_directory_client = storage_client.directory_client.create_sub_directory( + sub_folder + ) + + storage_client.file_client = storage_client.temp_sub_directory_client.create_file(file_name_tail) + else: + storage_client.file_client = storage_client.directory_client.create_file(source.split("/")[-1]) + + with open(source, "rb") as data: + if show_progress and not in_directory: + file_size, _ = get_directory_size(source) + file_size_in_mb = file_size / 10**6 + if file_size_in_mb < 1: + msg += Fore.GREEN + " (< 1 MB)" + else: + msg += Fore.GREEN + f" ({round(file_size_in_mb, 2)} MBs)" + cntx_manager = FileUploadProgressBar(msg=msg) + else: + cntx_manager = suppress() + + with cntx_manager as c: + callback = c.update_to if (show_progress and not in_directory) else None + if type(storage_client).__name__ == GEN2_STORAGE_CLIENT_NAME: + storage_client.file_client.upload_data( + data=data.read(), + overwrite=True, + validate_content=validate_content, + raw_response_hook=callback, + max_concurrency=MAX_CONCURRENCY, + ) + elif type(storage_client).__name__ == BLOB_STORAGE_CLIENT_NAME: + storage_client.container_client.upload_blob( + name=dest, + data=data, + validate_content=validate_content, + overwrite=storage_client.overwrite, + raw_response_hook=callback, + max_concurrency=MAX_CONCURRENCY, + connection_timeout=DEFAULT_CONNECTION_TIMEOUT, + ) + + storage_client.uploaded_file_count += 1 + + +def upload_directory( + storage_client: Union["BlobStorageClient", "Gen2StorageClient"], + source: Union[str, os.PathLike], + dest: str, + msg: str, + show_progress: bool, + ignore_file: IgnoreFile, +) -> None: + """Upload directory to remote storage. + + :param storage_client: Storage client object + :type storage_client: Union[ + azure.ai.ml._artifacts._blob_storage_helper.BlobStorageClient, + azure.ai.ml._artifacts._gen2_storage_helper.Gen2StorageClient] + :param source: Local path to project directory + :type source: Union[str, os.PathLike] + :param dest: Remote upload path for project directory (e.g. LocalUpload/<guid>/project_dir) + :type dest: str + :param msg: Message to be shown with progress bar (e.g. "Uploading <source>") + :type msg: str + :param show_progress: Whether to show progress bar or not + :type show_progress: bool + :param ignore_file: The .amlignore or .gitignore file in the project directory + :type ignore_file: azure.ai.ml._utils._asset_utils.IgnoreFile + :return: None + """ + source_path = Path(source).resolve() + prefix = "" if dest == "" else dest + "/" + prefix += os.path.basename(source_path) + "/" + + if ( + type(storage_client).__name__ == GEN2_STORAGE_CLIENT_NAME + ): # Only for Gen2StorageClient, Blob Storage doesn't have true directories + storage_client.sub_directory_client = storage_client.directory_client.create_sub_directory( + prefix.strip("/").split("/")[-1] + ) + + # Enumerate all files in the given directory and compose paths for them to be uploaded to in the remote storage + upload_paths = get_upload_files_from_folder( + source_path, + prefix=prefix, + ignore_file=ignore_file, + ) + size_dict = {} + total_size = 0 + + # Get each file's size for progress bar tracking + for path, _ in upload_paths: + # TODO: symbol links are already resolved + if os.path.islink(path): + path_size = os.path.getsize( + os.readlink(convert_windows_path_to_unix(path)) + ) # ensure we're counting the size of the linked file + else: + path_size = os.path.getsize(path) + size_dict[path] = path_size + total_size += path_size + + upload_paths = sorted(upload_paths) + if len(upload_paths) == 0: + raise EmptyDirectoryError( + message=EMPTY_DIRECTORY_ERROR.format(source), + no_personal_data_message=msg.format("[source]"), + target=ErrorTarget.ARTIFACT, + error_category=ErrorCategory.USER_ERROR, + ) + storage_client.total_file_count = len(upload_paths) + + if ( + type(storage_client).__name__ == BLOB_STORAGE_CLIENT_NAME + ): # Only for Gen2StorageClient, Blob Storage doesn't have true directories + # Only for BlobStorageClient + # Azure Blob doesn't allow metadata setting at the directory level, so the first + # file in the directory is designated as the file where the confirmation metadata + # will be added at the end of the upload. + storage_client.indicator_file = upload_paths[0][1] + storage_client.check_blob_exists() + + # Submit paths to workers for upload + num_cores = int(cpu_count()) * PROCESSES_PER_CORE + with ThreadPoolExecutor(max_workers=num_cores) as ex: + futures_dict = { + ex.submit( + upload_file, + storage_client=storage_client, + source=src, + dest=dest, + size=size_dict.get(src), + in_directory=True, + show_progress=show_progress, + ): (src, dest) + for (src, dest) in upload_paths + } + if show_progress: + warnings.simplefilter("ignore", category=TqdmWarning) + msg += f" ({round(total_size/10**6, 2)} MBs)" + is_windows = system() == "Windows" # Default unicode progress bar doesn't display well on Windows + with tqdm(total=total_size, desc=msg, ascii=is_windows) as pbar: + for future in as_completed(futures_dict): + future.result() # access result to propagate any exceptions + file_path_name = futures_dict[future][0] + pbar.update(size_dict.get(file_path_name) or 0) + + +@retry( + exceptions=ResourceExistsError, + failure_msg="Asset creation exceeded maximum retries.", + logger=module_logger, + max_attempts=MAX_AUTOINCREMENT_ATTEMPTS, +) +def _create_or_update_autoincrement( + name: str, + body: Any, + version_operation: Any, + container_operation: Any, + resource_group_name: str, + workspace_name: str, + **kwargs, +) -> Any: + try: + container = container_operation.get( + name=name, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + **kwargs, + ) + version = container.properties.next_version + + except ResourceNotFoundError: + version = "1" + + result = version_operation.create_or_update( + name=name, + version=version, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + body=body, + **kwargs, + ) + return result + + +def _get_next_version_from_container( + name: str, + container_operation: Any, + resource_group_name: str, + workspace_name: str, + registry_name: str = None, + **kwargs, +) -> str: + try: + container = ( + container_operation.get( + name=name, + resource_group_name=resource_group_name, + registry_name=registry_name, + **kwargs, + ) + if registry_name + else container_operation.get( + name=name, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + **kwargs, + ) + ) + version = container.properties.next_version + + except ResourceNotFoundError: + version = "1" + return version + + +def _get_next_latest_versions_from_container( + name: str, + container_operation: Any, + resource_group_name: str, + workspace_name: str, + registry_name: str = None, + **kwargs, +) -> str: + try: + container = ( + container_operation.get( + name=name, + resource_group_name=resource_group_name, + registry_name=registry_name, + **kwargs, + ) + if registry_name + else container_operation.get( + name=name, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + **kwargs, + ) + ) + next_version = container.properties.next_version + latest_version = container.properties.latest_version + + except ResourceNotFoundError: + next_version = "1" + latest_version = "1" + return next_version, latest_version + + +def _get_latest_version_from_container( + asset_name: str, + container_operation: Any, + resource_group_name: str, + workspace_name: Optional[str] = None, + registry_name: Optional[str] = None, + **kwargs, +) -> str: + try: + container = ( + container_operation.get( + name=asset_name, + resource_group_name=resource_group_name, + registry_name=registry_name, + **kwargs, + ) + if registry_name + else container_operation.get( + name=asset_name, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + **kwargs, + ) + ) + version = container.properties.latest_version + + except ResourceNotFoundError as e: + message = ( + f"Asset {asset_name} does not exist in registry {registry_name}." + if registry_name + else f"Asset {asset_name} does not exist in workspace {workspace_name}." + ) + no_personal_data_message = ( + "Asset {asset_name} does not exist in registry {registry_name}." + if registry_name + else "Asset {asset_name} does not exist in workspace {workspace_name}." + ) + raise ValidationException( + message=message, + no_personal_data_message=no_personal_data_message, + target=ErrorTarget.ASSET, + error_category=ErrorCategory.USER_ERROR, + error_type=ValidationErrorType.RESOURCE_NOT_FOUND, + ) from e + return version + + +def _get_latest( + asset_name: str, + version_operation: Any, + resource_group_name: str, + workspace_name: Optional[str] = None, + registry_name: Optional[str] = None, + order_by: Literal[OrderString.CREATED_AT, OrderString.CREATED_AT_DESC] = OrderString.CREATED_AT_DESC, + **kwargs, +) -> Union[ModelVersionData, DataVersionBaseData]: + """Retrieve the latest version of the asset with the given name. + + Latest is defined as the most recently created, not the most recently updated. + + :param asset_name: The asset name + :type asset_name: str + :param version_operation: Any + :type version_operation: Any + :param resource_group_name: The resource group name + :type resource_group_name: str + :param workspace_name: The workspace name + :type workspace_name: Optional[str] + :param registry_name: The registry name + :type registry_name: Optional[str] + :param order_by: Specifies how to order the results. Defaults to :attr:`OrderString.CREATED_AT_DESC` + :type order_by: Literal[OrderString.CREATED_AT, OrderString.CREATED_AT_DESC] + :return: The latest version of the requested asset + :rtype: Union[ModelVersionData, DataVersionBaseData] + """ + result = ( + version_operation.list( + name=asset_name, + resource_group_name=resource_group_name, + registry_name=registry_name, + order_by=order_by, + top=1, + **kwargs, + ) + if registry_name + else version_operation.list( + name=asset_name, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + order_by=order_by, + top=1, + **kwargs, + ) + ) + try: + latest = result.next() + except StopIteration: + latest = None + + if latest and isinstance(latest, ModelVersionResourceArmPaginatedResult): + # Data list return object doesn't require this since its elements are already DatasetVersionResources + latest = cast(ModelVersionData, latest) + if not latest: + message = ( + f"Asset {asset_name} does not exist in registry {registry_name}." + if registry_name + else f"Asset {asset_name} does not exist in workspace {workspace_name}." + ) + no_personal_data_message = ( + "Asset {asset_name} does not exist in registry {registry_name}." + if registry_name + else "Asset {asset_name} does not exist in workspace {workspace_name}." + ) + raise ValidationException( + message=message, + no_personal_data_message=no_personal_data_message, + target=ErrorTarget.ASSET, + error_category=ErrorCategory.USER_ERROR, + error_type=ValidationErrorType.RESOURCE_NOT_FOUND, + ) + return latest + + +def _archive_or_restore( + asset_operations: Union[ + "DataOperations", + "EnvironmentOperations", + "ModelOperations", + "ComponentOperations", + ], + version_operation: Union[ + "DataVersionsOperations", + "EnvironmentVersionsOperations", + "ModelVersionsOperations", + "ComponentVersionsOperations", + ], + container_operation: Union[ + "DataContainersOperations", + "EnvironmentContainersOperations", + "ModelContainersOperations", + "ComponentContainersOperations", + ], + is_archived: bool, + name: str, + version: Optional[str] = None, + label: Optional[str] = None, +) -> None: + resource_group_name = asset_operations._operation_scope._resource_group_name + workspace_name = asset_operations._workspace_name + registry_name = asset_operations._registry_name + if version and label: + msg = "Cannot specify both version and label." + raise ValidationException( + message=msg, + no_personal_data_message=msg, + target=ErrorTarget.ASSET, + error_category=ErrorCategory.USER_ERROR, + error_type=ValidationErrorType.RESOURCE_NOT_FOUND, + ) + if label: + version = _resolve_label_to_asset(asset_operations, name, label).version + + if version: + version_resource = ( + version_operation.get( + name=name, + version=version, + resource_group_name=resource_group_name, + registry_name=registry_name, + ) + if registry_name + else version_operation.get( + name=name, + version=version, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + ) + ) + version_resource.properties.is_archived = is_archived + version_resource.properties.stage = None + ( # pylint: disable=expression-not-assigned + version_operation.begin_create_or_update( + name=name, + version=version, + resource_group_name=resource_group_name, + registry_name=registry_name, + body=version_resource, + ) + if registry_name + else version_operation.create_or_update( + name=name, + version=version, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + body=version_resource, + ) + ) + else: + container_resource = ( + container_operation.get( + name=name, + resource_group_name=resource_group_name, + registry_name=registry_name, + ) + if registry_name + else container_operation.get( + name=name, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + ) + ) + container_resource.properties.is_archived = is_archived + ( # pylint: disable=expression-not-assigned + container_operation.create_or_update( + name=name, + resource_group_name=resource_group_name, + registry_name=registry_name, + body=container_resource, + ) + if registry_name + else container_operation.create_or_update( + name=name, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + body=container_resource, + ) + ) + + +def _resolve_label_to_asset( + assetOperations: Union[ + "DataOperations", + "ComponentOperations", + "EnvironmentOperations", + "ModelOperations", + "IndexOperations", + ], + name: str, + label: str, +) -> Asset: + """Returns the asset referred to by the given label. + + Throws if label does not refer to a version of the named asset + + :param assetOperations: The operations class used to retrieve the asset + :type assetOperations: + Union["DataOperations", "ComponentOperations", "EnvironmentOperations", "ModelOperations", "IndexOperations"] + :param name: The name of the asset + :type name: str + :param label: The label to resolve + :type label: str + :return: The requested asset + :rtype: Asset + """ + + resolver = assetOperations._managed_label_resolver.get(label, None) + if not resolver: + scope = "registry" if assetOperations._registry_name else "workspace" + msg = "Asset {} with version label {} does not exist in {}." + raise ValidationException( + message=msg.format(name, label, scope), + no_personal_data_message=msg.format("[name]", "[label]", "[scope]"), + target=ErrorTarget.ASSET, + error_type=ValidationErrorType.RESOURCE_NOT_FOUND, + ) + return resolver(name) + + +def _check_or_modify_auto_delete_setting( + autoDeleteSetting: Union[Dict, "AutoDeleteSetting"], +): + if autoDeleteSetting is not None: + if hasattr(autoDeleteSetting, "condition"): + condition = getattr(autoDeleteSetting, "condition") + condition = snake_to_camel(condition) + setattr(autoDeleteSetting, "condition", condition) + elif "condition" in autoDeleteSetting: + autoDeleteSetting["condition"] = snake_to_camel(autoDeleteSetting["condition"]) + + +def _validate_workspace_managed_datastore(path: Optional[Union[str, PathLike]]) -> Optional[Union[str, PathLike]]: + # block cumtomer specified path on managed datastore + if path.startswith(WORKSPACE_MANAGED_DATASTORE_WITH_SLASH) or path == WORKSPACE_MANAGED_DATASTORE: + path = path.rstrip("/") + + if path != WORKSPACE_MANAGED_DATASTORE: + raise AssetPathException( + message=INVALID_MANAGED_DATASTORE_PATH_ERROR_NO_PERSONAL_DATA, + tartget=ErrorTarget.DATA, + no_personal_data_message=INVALID_MANAGED_DATASTORE_PATH_ERROR_NO_PERSONAL_DATA, + error_category=ErrorCategory.USER_ERROR, + ) + + return path + "/paths" + return path + + +def _validate_auto_delete_setting_in_data_output( + auto_delete_setting: Optional[Union[Dict, "AutoDeleteSetting"]] +) -> None: + # avoid specifying auto_delete_setting in job output now + if auto_delete_setting: + raise ValidationException( + message=AUTO_DELETE_SETTING_NOT_ALLOWED_ERROR_NO_PERSONAL_DATA, + tartget=ErrorTarget.DATA, + no_personal_data_message=AUTO_DELETE_SETTING_NOT_ALLOWED_ERROR_NO_PERSONAL_DATA, + error_category=ErrorCategory.USER_ERROR, + ) + + +class FileUploadProgressBar(tqdm): + def __init__(self, msg: Optional[str] = None): + warnings.simplefilter("ignore", category=TqdmWarning) + is_windows = system() == "Windows" # Default unicode progress bar doesn't display well on Windows + super().__init__(unit="B", unit_scale=True, desc=msg, ascii=is_windows) + + def update_to(self, response): + current = response.context["upload_stream_current"] + self.total = response.context["data_stream_total"] + if current: + self.update(current - self.n) + + +class DirectoryUploadProgressBar(tqdm): + def __init__(self, dir_size: int, msg: Optional[str] = None): + super().__init__(unit="B", unit_scale=True, desc=msg, colour="green") + self.total = dir_size + self.completed = 0 + + def update_to(self, response): + current = None + if response.context["upload_stream_current"]: + current = response.context["upload_stream_current"] + self.completed + self.completed = current + if current: + self.update(current - self.n) + + +def get_storage_info_for_non_registry_asset( + service_client, workspace_name: str, name: str, version: str, resource_group: str +) -> Dict[str, str]: + """Get SAS uri and blob uri for non-registry asset. Note that this function won't return the same + SAS uri and blob uri for the same asset. It will return a new SAS uri and blob uri every time it is called. + :param service_client: Service client + :type service_client: AzureMachineLearningWorkspaces + :param workspace_name: The workspace name + :type workspace_name: str + :param name: Asset name + :type name: str + :param version: Asset version + :type version: str + :param resource_group: Resource group + :type resource_group: str + :return: The sas_uri and blob_uri + :rtype: Dict[str, str] + """ + request_body = PendingUploadRequestDto(pending_upload_type="TemporaryBlobReference") + response = service_client.code_versions.create_or_get_start_pending_upload( + resource_group_name=resource_group, + workspace_name=workspace_name, + name=name, + version=version, + body=request_body, + ) + + sas_info = { + "sas_uri": response.blob_reference_for_consumption.credential.sas_uri, + "blob_uri": response.blob_reference_for_consumption.blob_uri, + } + + return sas_info + + +def _get_existing_asset_name_and_version(existing_asset): + import re + + regex = r"/codes/([^/]+)/versions/([^/]+)" + + arm_id = existing_asset.id + match = re.search(regex, arm_id) + name = match.group(1) + version = match.group(2) + + return name, version diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_azureml_polling.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_azureml_polling.py new file mode 100644 index 00000000..fc148426 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_azureml_polling.py @@ -0,0 +1,48 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + + +import logging +from concurrent.futures import Future +from time import time +from typing import Optional, Union + +from azure.ai.ml.constants._common import LROConfigurations +from azure.core.polling import LROPoller +from azure.mgmt.core.polling.arm_polling import ARMPolling + +module_logger = logging.getLogger(__name__) + + +class AzureMLPolling(ARMPolling): + """A polling class for azure machine learning.""" + + def update_status(self): + """Update the current status of the LRO.""" + super().update_status() + print(".", end="", flush=True) + + +def polling_wait( + poller: Union[LROPoller, Future], + message: Optional[str] = None, + start_time: Optional[float] = None, +) -> None: + """Print out status while polling and time of operation once completed. + + :param poller: An poller which will return status update via function done(). + :type poller: Union[LROPoller, concurrent.futures.Future] + :param message: Message to print out before starting operation write-out. + :type message: Optional[str] + :param start_time: Start time of operation. + :type start_time: Optional[float] + """ + module_logger.info("%s", message) + poller.result(timeout=LROConfigurations.POLLING_TIMEOUT) + module_logger.info("Done.") + + if start_time: + end_time = time() + duration = divmod(int(round(end_time - start_time)), 60) + module_logger.info("(%sm %ss)\n", duration[0], duration[1]) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_cache_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_cache_utils.py new file mode 100644 index 00000000..a9947933 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_cache_utils.py @@ -0,0 +1,437 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- +import hashlib +import logging +import os.path +import threading +import time +from collections import defaultdict +from concurrent.futures import ThreadPoolExecutor +from dataclasses import dataclass +from pathlib import Path +from typing import Callable, Dict, List, Optional, Tuple, Union + +from azure.ai.ml._utils._asset_utils import get_object_hash +from azure.ai.ml._utils.utils import ( + get_versioned_base_directory_for_cache, + is_concurrent_component_registration_enabled, + is_on_disk_cache_enabled, + is_private_preview_enabled, + write_to_shared_file, +) +from azure.ai.ml.constants._common import ( + AZUREML_COMPONENT_REGISTRATION_MAX_WORKERS, + AzureMLResourceType, + DefaultOpenEncoding, +) +from azure.ai.ml.entities import Component +from azure.ai.ml.entities._builders import BaseNode +from azure.ai.ml.entities._component.code import ComponentCodeMixin +from azure.ai.ml.operations._operation_orchestrator import _AssetResolver + +logger = logging.getLogger(__name__) + +_ANONYMOUS_HASH_PREFIX = "anonymous-component-" +_YAML_SOURCE_PREFIX = "yaml-source-" +_CODE_INVOLVED_PREFIX = "code-involved-" +EXPIRE_TIME_IN_SECONDS = 60 * 60 * 24 * 7 # 7 days + +_node_resolution_lock = defaultdict(threading.Lock) + + +@dataclass +class _CacheContent: + component_ref: Component + # in-memory hash assume that the code folders are not changed during the run and + # use the hash of code path instead of code content to simplify the calculation + in_memory_hash: str + # on-disk hash will be calculated base on code content if applicable, + # so it will work even if the code folders are changed among runs + on_disk_hash: Optional[str] = None + arm_id: Optional[str] = None + + def update_on_disk_hash(self): + self.on_disk_hash = CachedNodeResolver.calc_on_disk_hash_for_component(self.component_ref, self.in_memory_hash) + + +class CachedNodeResolver(object): + """Class to resolve component in nodes with cached component resolution results. + + This class is thread-safe if: + 1) self._resolve_nodes is not called concurrently. We guarantee this with a lock in self.resolve_nodes. + a) self._resolve_nodes won't be called recursively as all nodes will be skipped on + calling self.register_node_for_lazy_resolution. + b) it can't be called concurrently as node resolution involves filling back and will change the + state of nodes, e.g., hash of its inner component. + 2) self._resolve_component is only called concurrently on independent components + a) we have used an in-memory component hash to deduplicate components to resolve first; + b) dependent components have been resolved before registered as nodes are registered & resolved + layer by layer; + c) dependent code will never be an instance, so it won't cause cache hit issue described in d; + d) resolution of potential shared dependencies (1 instance used in 2 components) other than components + are thread-safe as they do not involve further dependency resolution. However, it's still a good practice to + resolve them before calling self.register_node_for_lazy_resolution as it will impact cache hit rate. + For example, if: + node1.component, node2.component = Component(environment=env1, ...), Component(environment=env1, ...) + root + | \ + subgraph node2 + | + node1 + when registering node1, its component will be: + { + "name": "component1", + "environment": { + ... + } + ... + } + Its in-memory hash will be `hash_a` on registration. + Then when registering node2, the component will be: + { + "name": "component1", + "environment": "/subscriptions/.../environments/...", + ... + } + Its in-memory hash will be `hash_b`, which will be a cache miss. + """ + + def __init__( + self, + resolver: Callable[[Union[Component, str]], str], + client_key: str, + ): + self._resolver = resolver + self._cache: Dict[str, _CacheContent] = {} + self._nodes_to_resolve: List[BaseNode] = [] + + hash_obj = hashlib.sha256() + hash_obj.update(client_key.encode("utf-8")) + self._client_hash = hash_obj.hexdigest() + # the same client share 1 lock + self._lock = _node_resolution_lock[self._client_hash] + + @staticmethod + def _get_component_registration_max_workers() -> int: + """Get the max workers for component registration. + + Before Python 3.8, the default max_worker is the number of processors multiplied by 5. + It may send a large number of the uploading snapshot requests that will occur remote refuses requests. + In order to avoid retrying the upload requests, max_worker will use the default value in Python 3.8, + min(32, os.cpu_count + 4). + + 1 risk is that, asset_utils will create a new thread pool to upload files in subprocesses, which may cause + the number of threads exceed the max_worker. + + :return: The number of workers to use for component registration + :rtype: int + """ + default_max_workers = min(32, (os.cpu_count() or 1) + 4) + try: + max_workers = int(os.environ.get(AZUREML_COMPONENT_REGISTRATION_MAX_WORKERS, default_max_workers)) + except ValueError: + logger.info( + "Environment variable %s with value %s set but failed to parse. " + "Use the default max_worker %s as registration thread pool max_worker." + "Please reset the value to an integer.", + AZUREML_COMPONENT_REGISTRATION_MAX_WORKERS, + os.environ.get(AZUREML_COMPONENT_REGISTRATION_MAX_WORKERS), + default_max_workers, + ) + max_workers = default_max_workers + return max_workers + + @staticmethod + def _get_in_memory_hash_for_component(component: Component) -> str: + """Get a hash for a component. + + This function assumes that there is no change in code folder among hash calculations, which is true during + resolution of 1 root pipeline component/job. + + :param component: The component + :type component: Component + :return: The hash of the component + :rtype: str + """ + if not isinstance(component, Component): + # this shouldn't happen; handle it in case invalid call is made outside this class + raise ValueError(f"Component {component} is not a Component object.") + + # For components with code, its code will be an absolute path before uploaded to blob, + # so we can use a mixture of its anonymous hash and its source path as its hash, in case + # there are 2 components with same code but different ignore files + # Here we can check if the component has a source path instead of check if it has code, as + # there is no harm to add a source path to the hash even if the component doesn't have code + # Note that here we assume that the content of code folder won't change during the submission + if component._source_path: # pylint: disable=protected-access + object_hash = hashlib.sha256() + object_hash.update(component._get_anonymous_hash().encode("utf-8")) # pylint: disable=protected-access + object_hash.update(component._source_path.encode("utf-8")) # pylint: disable=protected-access + return _YAML_SOURCE_PREFIX + object_hash.hexdigest() + # For components without code, like pipeline component, their dependencies have already + # been resolved before calling this function, so we can use their anonymous hash directly + return _ANONYMOUS_HASH_PREFIX + component._get_anonymous_hash() # pylint: disable=protected-access + + @staticmethod + def calc_on_disk_hash_for_component(component: Component, in_memory_hash: str) -> str: + """Get a hash for a component. + + This function will calculate the hash based on the component's code folder if the component has code, so it's + unique even if code folder is changed. + + :param component: The component to hash + :type component: Component + :param in_memory_hash: :attr:`_CacheNodeResolver.in_memory_hash` + :type in_memory_hash: str + :return: The hash of the component + :rtype: str + """ + if not isinstance(component, Component): + # this shouldn't happen; handle it in case invalid call is made outside this class + raise ValueError(f"Component {component} is not a Component object.") + + # TODO: calculate hash without resolving additional includes (copy code to temp folder) + # note that it's still thread-safe with current implementation, as only read operations are + # done on the original code folder + if not ( + isinstance(component, ComponentCodeMixin) + and component._with_local_code() # pylint: disable=protected-access + ): + return in_memory_hash + + with component._build_code() as code: # pylint: disable=protected-access + if hasattr(code, "_upload_hash"): + content_hash = code._upload_hash # pylint: disable=protected-access + else: + code_path = code.path if os.path.isabs(code.path) else os.path.join(code.base_path, code.path) + if os.path.exists(code_path): + content_hash = get_object_hash(code_path) + else: + # this will be gated by schema validation, so it shouldn't happen except for mock tests + return in_memory_hash + + object_hash = hashlib.sha256() + object_hash.update(in_memory_hash.encode("utf-8")) + + object_hash.update(content_hash.encode("utf-8")) + return _CODE_INVOLVED_PREFIX + object_hash.hexdigest() + + @property + def _on_disk_cache_dir(self) -> Path: + """Get the base path for on disk cache. + + :return: The base path for the on disk cache + :rtype: Path + """ + return get_versioned_base_directory_for_cache().joinpath( + "components", + self._client_hash, + ) + + def _get_on_disk_cache_path(self, on_disk_hash: str) -> Path: + """Get the on disk cache path for a component. + + :param on_disk_hash: The hash of the component + :type on_disk_hash: str + :return: The path to the disk cache + :rtype: Path + """ + return self._on_disk_cache_dir.joinpath(on_disk_hash) + + def _load_from_on_disk_cache(self, on_disk_hash: str) -> Optional[str]: + """Load component arm id from on disk cache. + + :param on_disk_hash: The hash of the component + :type on_disk_hash: str + :return: The cached component arm id if reading was successful, None otherwise + :rtype: Optional[str] + """ + # on-disk cache will expire in a new SDK version + on_disk_cache_path = self._get_on_disk_cache_path(on_disk_hash) + if on_disk_cache_path.is_file() and time.time() - on_disk_cache_path.stat().st_ctime < EXPIRE_TIME_IN_SECONDS: + try: + return on_disk_cache_path.read_text(encoding=DefaultOpenEncoding.READ).strip() + except (OSError, PermissionError) as e: + logger.warning( + "Failed to read on-disk cache for component due to %s. " + "Please check if the file %s is in use or current user doesn't have the permission.", + type(e).__name__, + on_disk_cache_path.as_posix(), + ) + return None + + def _save_to_on_disk_cache(self, on_disk_hash: str, arm_id: str) -> None: + """Save component arm id to on disk cache. + + :param on_disk_hash: The on disk hash of the component + :type on_disk_hash: str + :param arm_id: The component ARM ID + :type arm_id: str + """ + # this shouldn't happen in real case, but in case of current mock tests and potential future changes + if not isinstance(arm_id, str): + return + on_disk_cache_path = self._get_on_disk_cache_path(on_disk_hash) + on_disk_cache_path.parent.mkdir(parents=True, exist_ok=True) + try: + write_to_shared_file(on_disk_cache_path, arm_id) + except PermissionError: + logger.warning( + "Failed to save on-disk cache for component due to permission error. " + "Please check if the file %s is in use or current user doesn't have the permission.", + on_disk_cache_path.as_posix(), + ) + + def _resolve_cache_contents(self, cache_contents_to_resolve: List[_CacheContent], resolver: _AssetResolver): + """Resolve all components to resolve and save the results in cache. + + :param cache_contents_to_resolve: The cache contents to resolve + :type cache_contents_to_resolve: List[_CacheContent] + :param resolver: The resolver function + :type resolver: _AssetResolver + """ + + def _map_func(_cache_content: _CacheContent): + _cache_content.arm_id = resolver(_cache_content.component_ref, azureml_type=AzureMLResourceType.COMPONENT) + if is_on_disk_cache_enabled() and is_private_preview_enabled(): + self._save_to_on_disk_cache(_cache_content.on_disk_hash, _cache_content.arm_id) + + if ( + len(cache_contents_to_resolve) > 1 + and is_concurrent_component_registration_enabled() + and is_private_preview_enabled() + ): + # given deduplication has already been done, we can safely assume that there is no + # conflict in concurrent local cache access + with ThreadPoolExecutor(max_workers=self._get_component_registration_max_workers()) as executor: + list(executor.map(_map_func, cache_contents_to_resolve)) + else: + list(map(_map_func, cache_contents_to_resolve)) + + def _prepare_items_to_resolve(self) -> Tuple[Dict[str, List[BaseNode]], List[_CacheContent]]: + """Pop all nodes in self._nodes_to_resolve to prepare cache contents to resolve and nodes to resolve. Nodes in + self._nodes_to_resolve will be grouped by component hash and saved to a dict of list. Distinct dependent + components not in current cache will be saved to a list. + + :return: a tuple of (dict of nodes to resolve, list of cache contents to resolve) + :rtype: Tuple[Dict[str, List[BaseNode]], List[_CacheContent]] + """ + _components = list(map(lambda x: x._component, self._nodes_to_resolve)) # pylint: disable=protected-access + # we can do concurrent component in-memory hash calculation here + in_memory_component_hashes = map(self._get_in_memory_hash_for_component, _components) + + dict_of_nodes_to_resolve = defaultdict(list) + cache_contents_to_resolve: List[_CacheContent] = [] + for node, component_hash in zip(self._nodes_to_resolve, in_memory_component_hashes): + dict_of_nodes_to_resolve[component_hash].append(node) + if component_hash not in self._cache: + cache_content = _CacheContent( + component_ref=node._component, # pylint: disable=protected-access + in_memory_hash=component_hash, + ) + self._cache[component_hash] = cache_content + cache_contents_to_resolve.append(cache_content) + self._nodes_to_resolve.clear() + return dict_of_nodes_to_resolve, cache_contents_to_resolve + + def _resolve_cache_contents_from_disk(self, cache_contents_to_resolve: List[_CacheContent]) -> List[_CacheContent]: + """Check on-disk cache to resolve cache contents in cache_contents_to_resolve and return unresolved cache + contents. + + :param cache_contents_to_resolve: The cache contents to resolve + :type cache_contents_to_resolve: List[_CacheContent] + :return: Unresolved cache contents + :rtype: List[_CacheContent] + """ + # Note that we should recalculate the hash based on code for local cache, as + # we can't assume that the code folder won't change among dependency + # On-disk hash calculation can be slow as it involved data copying and artifact downloading. + # It is thread-safe given: + # 1. artifact downloading is thread-safe as we have a lock in ArtifactCache + # 2. data copying is thread-safe as there is only read operation on source folder + # and target folder is unique for each thread + if ( + len(cache_contents_to_resolve) > 1 + and is_concurrent_component_registration_enabled() + and is_private_preview_enabled() + ): + with ThreadPoolExecutor(max_workers=self._get_component_registration_max_workers()) as executor: + executor.map(_CacheContent.update_on_disk_hash, cache_contents_to_resolve) + else: + list(map(_CacheContent.update_on_disk_hash, cache_contents_to_resolve)) + + left_cache_contents_to_resolve = [] + # need to deduplicate disk hash first if concurrent resolution is enabled + for cache_content in cache_contents_to_resolve: + cache_content.arm_id = self._load_from_on_disk_cache(cache_content.on_disk_hash) + if not cache_content.arm_id: + left_cache_contents_to_resolve.append(cache_content) + + return left_cache_contents_to_resolve + + def _fill_back_component_to_nodes(self, dict_of_nodes_to_resolve: Dict[str, List[BaseNode]]): + """Fill back resolved component to nodes. + + :param dict_of_nodes_to_resolve: The nodes to resolve + :type dict_of_nodes_to_resolve: Dict[str, List[BaseNode]] + """ + for component_hash, nodes in dict_of_nodes_to_resolve.items(): + cache_content = self._cache[component_hash] + for node in nodes: + node._component = cache_content.arm_id # pylint: disable=protected-access + + def _resolve_nodes(self): + """Processing logic of self.resolve_nodes. + + Should not be called in subgraph creation. + """ + dict_of_nodes_to_resolve, cache_contents_to_resolve = self._prepare_items_to_resolve() + + if is_on_disk_cache_enabled() and is_private_preview_enabled(): + cache_contents_to_resolve = self._resolve_cache_contents_from_disk(cache_contents_to_resolve) + + self._resolve_cache_contents(cache_contents_to_resolve, resolver=self._resolver) + + self._fill_back_component_to_nodes(dict_of_nodes_to_resolve) + + def register_node_for_lazy_resolution(self, node: BaseNode): + """Register a node with its component to resolve. + + :param node: The node + :type node: BaseNode + """ + component = node._component # pylint: disable=protected-access + + # directly resolve node and skip registration if the resolution involves no remote call + # so that all node will be skipped when resolving a subgraph recursively + if isinstance(component, str): + node._component = self._resolver( # pylint: disable=protected-access + component, azureml_type=AzureMLResourceType.COMPONENT + ) + return + if component.id is not None: + node._component = component.id # pylint: disable=protected-access + return + + self._nodes_to_resolve.append(node) + + def resolve_nodes(self): + """Resolve all dependent components with resolver and set resolved component arm id back to newly registered + nodes. + + Registered nodes will be cleared after resolution. + """ + if not self._nodes_to_resolve: + return + + # Lock here as node resolution involves filling back and will change the + # state of nodes, e.g. hash of its inner component. + # This will happen only on concurrent external calls; In 1 external call, all nodes in + # subgraph will be skipped on register_node_for_lazy_resolution when resolving subgraph + self._lock.acquire() + try: + self._resolve_nodes() + finally: + # release lock even if exception happens + self._lock.release() diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_data_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_data_utils.py new file mode 100644 index 00000000..bde91d34 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_data_utils.py @@ -0,0 +1,82 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import io +import json +import logging +from pathlib import Path +from tempfile import TemporaryDirectory +from typing import Dict, Union +from urllib.parse import urljoin, urlparse + +import yaml +from jsonschema import Draft7Validator, ValidationError +from jsonschema.exceptions import best_match + +from azure.ai.ml._artifacts._artifact_utilities import get_datastore_info, get_storage_client +from azure.ai.ml._artifacts._constants import INVALID_MLTABLE_METADATA_SCHEMA_ERROR, INVALID_MLTABLE_METADATA_SCHEMA_MSG +from azure.ai.ml.constants._common import DefaultOpenEncoding +from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException +from azure.ai.ml.operations._datastore_operations import DatastoreOperations + +from ._http_utils import HttpPipeline +from ._storage_utils import AzureMLDatastorePathUri +from .utils import load_yaml + +module_logger = logging.getLogger(__name__) + + +def download_mltable_metadata_schema(mltable_schema_url: str, requests_pipeline: HttpPipeline): + response = requests_pipeline.get(mltable_schema_url) + return response.json() + + +def read_local_mltable_metadata_contents(*, path: str) -> Dict: + metadata_path = str(Path(path, "MLTable")) + return load_yaml(metadata_path) + + +def read_remote_mltable_metadata_contents( + *, + base_uri: str, + datastore_operations: DatastoreOperations, + requests_pipeline: HttpPipeline, +) -> Union[Dict, None]: + scheme = urlparse(base_uri).scheme + if scheme == "https": + response = requests_pipeline.get(urljoin(base_uri, "MLTable")) + yaml_file = io.BytesIO(response.content) + return yaml.safe_load(yaml_file) + if scheme == "azureml": + datastore_path_uri = AzureMLDatastorePathUri(base_uri) + datastore_info = get_datastore_info(datastore_operations, datastore_path_uri.datastore) + storage_client = get_storage_client(**datastore_info) + with TemporaryDirectory() as tmp_dir: + starts_with = datastore_path_uri.path.rstrip("/") + storage_client.download(f"{starts_with}/MLTable", tmp_dir) + downloaded_mltable_path = Path(tmp_dir, "MLTable") + with open(downloaded_mltable_path, "r", encoding=DefaultOpenEncoding.READ) as f: + return yaml.safe_load(f) + return None + + +def validate_mltable_metadata(*, mltable_metadata_dict: Dict, mltable_schema: Dict): + # use json-schema to validate dict + error: Union[ValidationError, None] = best_match(Draft7Validator(mltable_schema).iter_errors(mltable_metadata_dict)) + if error: + err_path = ".".join(error.path) + err_path = f"{err_path}: " if err_path != "" else "" + msg = INVALID_MLTABLE_METADATA_SCHEMA_ERROR.format( + jsonSchemaErrorPath=err_path, + jsonSchemaMessage=error.message, + invalidMLTableMsg=INVALID_MLTABLE_METADATA_SCHEMA_MSG, + invalidSchemaSnippet=json.dumps(error.schema, indent=2), + ) + raise ValidationException( + message=msg, + no_personal_data_message=INVALID_MLTABLE_METADATA_SCHEMA_MSG, + error_type=ValidationErrorType.INVALID_VALUE, + target=ErrorTarget.DATA, + error_category=ErrorCategory.USER_ERROR, + ) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_endpoint_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_endpoint_utils.py new file mode 100644 index 00000000..b8bab283 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_endpoint_utils.py @@ -0,0 +1,229 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +# pylint: disable=protected-access + +import ast +import concurrent.futures +import logging +import time +from concurrent.futures import Future +from pathlib import Path +from typing import Any, Callable, Dict, Optional, Union + +from azure.ai.ml._restclient.v2020_09_01_dataplanepreview.models import DataVersion, UriFileJobOutput +from azure.ai.ml._utils._arm_id_utils import is_ARM_id_for_resource, is_registry_id_for_resource +from azure.ai.ml._utils._logger_utils import initialize_logger_info +from azure.ai.ml.constants._common import ARM_ID_PREFIX, AzureMLResourceType, DefaultOpenEncoding, LROConfigurations +from azure.ai.ml.entities import BatchDeployment +from azure.ai.ml.entities._assets._artifacts.code import Code +from azure.ai.ml.entities._deployment.deployment import Deployment +from azure.ai.ml.entities._deployment.model_batch_deployment import ModelBatchDeployment +from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, MlException, ValidationErrorType, ValidationException +from azure.ai.ml.operations._operation_orchestrator import OperationOrchestrator +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ServiceRequestTimeoutError, + map_error, +) +from azure.core.polling import LROPoller +from azure.core.rest import HttpResponse +from azure.mgmt.core.exceptions import ARMErrorFormat + +module_logger = logging.getLogger(__name__) +initialize_logger_info(module_logger, terminator="") + + +def get_duration(start_time: float) -> None: + """Calculates the duration of the Long running operation took to finish. + + :param start_time: Start time + :type start_time: float + """ + end_time = time.time() + duration = divmod(int(round(end_time - start_time)), 60) + module_logger.warning("(%sm %ss)\n", duration[0], duration[1]) + + +def polling_wait( + poller: Union[LROPoller, Future], + message: Optional[str] = None, + start_time: Optional[float] = None, + is_local=False, + timeout=LROConfigurations.POLLING_TIMEOUT, +) -> Any: + """Print out status while polling and time of operation once completed. + + :param poller: An poller which will return status update via function done(). + :type poller: Union[LROPoller, concurrent.futures.Future] + :param (str, optional) message: Message to print out before starting operation write-out. + :param (float, optional) start_time: Start time of operation. + :param (bool, optional) is_local: If poller is for a local endpoint, so the timeout is removed. + :param (int, optional) timeout: New value to overwrite the default timeout. + """ + module_logger.warning("%s", message) + if is_local: + # We removed timeout on local endpoints in case it takes a long time + # to pull image or install conda env. + + # We want user to be able to see that. + + while not poller.done(): + module_logger.warning(".") + time.sleep(LROConfigurations.SLEEP_TIME) + else: + poller.result(timeout=timeout) + + if poller.done(): + module_logger.warning("Done ") + else: + module_logger.warning("Timeout waiting for long running operation") + + if start_time: + get_duration(start_time) + + +def local_endpoint_polling_wrapper(func: Callable, message: str, **kwargs) -> Any: + """Wrapper for polling local endpoint operations. + + :param func: Name of the endpoint. + :type func: Callable + :param message: Message to print out before starting operation write-out. + :type message: str + :return: The type returned by Func + """ + pool = concurrent.futures.ThreadPoolExecutor() + start_time = time.time() + event = pool.submit(func, **kwargs) + polling_wait(poller=event, start_time=start_time, message=message, is_local=True) + return event.result() + + +def validate_response(response: HttpResponse) -> None: + """Validates the response of POST requests, throws on error. + + :param HttpResponse response: the response of a POST requests + :raises Exception: Raised when response is not json serializable + :raises HttpResponseError: Raised when the response signals that an error occurred + """ + r_json = {} + + if response.status_code not in [200, 201]: + # We need to check for an empty response body or catch the exception raised. + # It is possible the server responded with a 204 No Content response, and json parsing fails. + if response.status_code != 204: + try: + r_json = response.json() + except ValueError as e: + # exception is not in the json format + msg = response.content.decode("utf-8") + raise MlException(message=msg, no_personal_data_message=msg) from e + failure_msg = r_json.get("error", {}).get("message", response) + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 408: ServiceRequestTimeoutError, + 409: ResourceExistsError, + 424: HttpResponseError, + } + map_error(status_code=response.status_code, response=response, error_map=error_map) + raise HttpResponseError(response=response, message=failure_msg, error_format=ARMErrorFormat) + + +def upload_dependencies(deployment: Deployment, orchestrators: OperationOrchestrator) -> None: + """Upload code, dependency, model dependencies. For BatchDeployment only register compute. + + :param Deployment deployment: Endpoint deployment object. + :param OperationOrchestrator orchestrators: Operation Orchestrator. + """ + + module_logger.debug("Uploading the dependencies for deployment %s", deployment.name) + + # Create a code asset if code is not already an ARM ID + if ( + deployment.code_configuration + and not is_ARM_id_for_resource(deployment.code_configuration.code, AzureMLResourceType.CODE) + and not is_registry_id_for_resource(deployment.code_configuration.code) + ): + if deployment.code_configuration.code.startswith(ARM_ID_PREFIX): + deployment.code_configuration.code = orchestrators.get_asset_arm_id( + deployment.code_configuration.code[len(ARM_ID_PREFIX) :], + azureml_type=AzureMLResourceType.CODE, + ) + else: + deployment.code_configuration.code = orchestrators.get_asset_arm_id( + Code(base_path=deployment._base_path, path=deployment.code_configuration.code), + azureml_type=AzureMLResourceType.CODE, + ) + + if not is_registry_id_for_resource(deployment.environment): + deployment.environment = ( + orchestrators.get_asset_arm_id(deployment.environment, azureml_type=AzureMLResourceType.ENVIRONMENT) + if deployment.environment + else None + ) + if not is_registry_id_for_resource(deployment.model): + deployment.model = ( + orchestrators.get_asset_arm_id(deployment.model, azureml_type=AzureMLResourceType.MODEL) + if deployment.model + else None + ) + if isinstance(deployment, (BatchDeployment, ModelBatchDeployment)) and deployment.compute: + deployment.compute = orchestrators.get_asset_arm_id( + deployment.compute, azureml_type=AzureMLResourceType.COMPUTE + ) + + +def validate_scoring_script(deployment): + score_script_path = Path(deployment.base_path).joinpath( + deployment.code_configuration.code, deployment.scoring_script + ) + try: + with open(score_script_path, "r", encoding=DefaultOpenEncoding.READ) as script: + contents = script.read() + try: + ast.parse(contents, score_script_path) + except SyntaxError as err: + err.filename = err.filename.split("/")[-1] + msg = ( + f"Failed to submit deployment {deployment.name} due to syntax errors " + f"in scoring script {err.filename}.\nError on line {err.lineno}: " + f"{err.text}\nIf you wish to bypass this validation use --skip-script-validation paramater." + ) + + np_msg = ( + "Failed to submit deployment due to syntax errors in deployment script." + "\n If you wish to bypass this validation use --skip-script-validation paramater." + ) + raise ValidationException( + message=msg, + target=( + ErrorTarget.BATCH_DEPLOYMENT + if isinstance(deployment, BatchDeployment) + else ErrorTarget.ONLINE_DEPLOYMENT + ), + no_personal_data_message=np_msg, + error_category=ErrorCategory.USER_ERROR, + error_type=ValidationErrorType.CANNOT_PARSE, + ) from err + except OSError as err: + raise MlException( + message=f"Failed to open scoring script {err.filename}.", + no_personal_data_message="Failed to open scoring script.", + ) from err + + +def convert_v1_dataset_to_v2(output_data_set: DataVersion, file_name: str) -> Dict[str, Any]: + if file_name: + v2_dataset = UriFileJobOutput( + uri=f"azureml://datastores/{output_data_set.datastore_id}/paths/{output_data_set.path}/{file_name}" + ).serialize() + else: + v2_dataset = UriFileJobOutput( + uri=f"azureml://datastores/{output_data_set.datastore_id}/paths/{output_data_set.path}" + ).serialize() + return {"output_name": v2_dataset} diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_experimental.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_experimental.py new file mode 100644 index 00000000..42b0bee6 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_experimental.py @@ -0,0 +1,156 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import functools +import inspect +import logging +import sys +from typing import Callable, Type, TypeVar, Union + +from typing_extensions import ParamSpec + +from azure.ai.ml.constants._common import ( + DOCSTRING_DEFAULT_INDENTATION, + DOCSTRING_TEMPLATE, + EXPERIMENTAL_CLASS_MESSAGE, + EXPERIMENTAL_LINK_MESSAGE, + EXPERIMENTAL_METHOD_MESSAGE, +) + +_warning_cache = set() +module_logger = logging.getLogger(__name__) + +TExperimental = TypeVar("TExperimental", bound=Union[Type, Callable]) +P = ParamSpec("P") +T = TypeVar("T") + + +def experimental(wrapped: TExperimental) -> TExperimental: + """Add experimental tag to a class or a method. + + :param wrapped: Either a Class or Function to mark as experimental + :type wrapped: TExperimental + :return: The wrapped class or method + :rtype: TExperimental + """ + if inspect.isclass(wrapped): + return _add_class_docstring(wrapped) + if inspect.isfunction(wrapped): + return _add_method_docstring(wrapped) + return wrapped + + +def _add_class_docstring(cls: Type[T]) -> Type[T]: + """Add experimental tag to the class doc string. + + :return: The updated class + :rtype: Type[T] + """ + + P2 = ParamSpec("P2") + + def _add_class_warning(func: Callable[P2, None]) -> Callable[P2, None]: + """Add warning message for class __init__. + + :param func: The original __init__ function + :type func: Callable[P2, None] + :return: Updated __init__ + :rtype: Callable[P2, None] + """ + + @functools.wraps(func) + def wrapped(*args, **kwargs): + message = "Class {0}: {1} {2}".format(cls.__name__, EXPERIMENTAL_CLASS_MESSAGE, EXPERIMENTAL_LINK_MESSAGE) + if not _should_skip_warning() and not _is_warning_cached(message): + module_logger.warning(message) + return func(*args, **kwargs) + + return wrapped + + doc_string = DOCSTRING_TEMPLATE.format(EXPERIMENTAL_CLASS_MESSAGE, EXPERIMENTAL_LINK_MESSAGE) + if cls.__doc__: + cls.__doc__ = _add_note_to_docstring(cls.__doc__, doc_string) + else: + cls.__doc__ = doc_string + ">" + cls.__init__ = _add_class_warning(cls.__init__) + return cls + + +def _add_method_docstring(func: Callable[P, T] = None) -> Callable[P, T]: + """Add experimental tag to the method doc string. + + :param func: The function to update + :type func: Callable[P, T] + :return: A wrapped method marked as experimental + :rtype: Callable[P,T] + """ + doc_string = DOCSTRING_TEMPLATE.format(EXPERIMENTAL_METHOD_MESSAGE, EXPERIMENTAL_LINK_MESSAGE) + if func.__doc__: + func.__doc__ = _add_note_to_docstring(func.__doc__, doc_string) + else: + # '>' is required. Otherwise the note section can't be generated + func.__doc__ = doc_string + ">" + + @functools.wraps(func) + def wrapped(*args: P.args, **kwargs: P.kwargs) -> T: + message = "Method {0}: {1} {2}".format(func.__name__, EXPERIMENTAL_METHOD_MESSAGE, EXPERIMENTAL_LINK_MESSAGE) + if not _should_skip_warning() and not _is_warning_cached(message): + module_logger.warning(message) + return func(*args, **kwargs) + + return wrapped + + +def _add_note_to_docstring(doc_string: str, note: str) -> str: + """Adds experimental note to docstring at the top and correctly indents original docstring. + + :param doc_string: The docstring + :type doc_string: str + :param note: The note to add to the docstring + :type note: str + :return: Updated docstring + :rtype: str + """ + indent = _get_indentation_size(doc_string) + doc_string = doc_string.rjust(len(doc_string) + indent) + return note + doc_string + + +def _get_indentation_size(doc_string: str) -> int: + """Finds the minimum indentation of all non-blank lines after the first line. + + :param doc_string: The docstring + :type doc_string: str + :return: Minimum number of indentation of the docstring + :rtype: int + """ + lines = doc_string.expandtabs().splitlines() + indent = sys.maxsize + for line in lines[1:]: + stripped = line.lstrip() + if stripped: + indent = min(indent, len(line) - len(stripped)) + return indent if indent < sys.maxsize else DOCSTRING_DEFAULT_INDENTATION + + +def _should_skip_warning(): + skip_warning_msg = False + + # Cases where we want to suppress the warning: + # 1. When converting from REST object to SDK object + for frame in inspect.stack(): + if frame.function == "_from_rest_object": + skip_warning_msg = True + break + + return skip_warning_msg + + +def _is_warning_cached(warning_msg): + # use cache to make sure we only print same warning message once under same session + # this prevents duplicated warnings got printed when user does a loop call on a method or a class + if warning_msg in _warning_cache: + return True + _warning_cache.add(warning_msg) + return False diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_feature_store_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_feature_store_utils.py new file mode 100644 index 00000000..8bcf4e2e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_feature_store_utils.py @@ -0,0 +1,109 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +# pylint: disable=protected-access +from datetime import datetime +from pathlib import Path +from tempfile import TemporaryDirectory +from typing import TYPE_CHECKING, Dict, Union +from urllib.parse import urlparse + +import yaml + +from .._artifacts._artifact_utilities import get_datastore_info, get_storage_client +from .._restclient.v2023_10_01.operations import ( # pylint: disable = unused-import + FeaturesetContainersOperations, + FeaturesetVersionsOperations, + FeaturestoreEntityContainersOperations, + FeaturestoreEntityVersionsOperations, +) +from ..constants._common import DefaultOpenEncoding +from ..exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException +from ..operations._datastore_operations import DatastoreOperations +from ._storage_utils import AzureMLDatastorePathUri +from .utils import load_yaml + +if TYPE_CHECKING: + from azure.ai.ml.operations._feature_set_operations import FeatureSetOperations + from azure.ai.ml.operations._feature_store_entity_operations import FeatureStoreEntityOperations + + +def read_feature_set_metadata(*, path: str) -> Dict: + metadata_path = str(Path(path, "FeatureSetSpec.yaml")) + return load_yaml(metadata_path) + + +def read_remote_feature_set_spec_metadata( + *, + base_uri: str, + datastore_operations: DatastoreOperations, +) -> Union[Dict, None]: + scheme = urlparse(base_uri).scheme + if scheme == "azureml": + datastore_path_uri = AzureMLDatastorePathUri(base_uri) + datastore_info = get_datastore_info(datastore_operations, datastore_path_uri.datastore) + storage_client = get_storage_client(**datastore_info) + with TemporaryDirectory() as tmp_dir: + starts_with = datastore_path_uri.path.rstrip("/") + storage_client.download(f"{starts_with}/FeatureSetSpec.yaml", tmp_dir) + downloaded_spec_path = Path(tmp_dir, "FeatureSetSpec.yaml") + with open(downloaded_spec_path, "r", encoding=DefaultOpenEncoding.READ) as f: + return yaml.safe_load(f) + return None + + +def _archive_or_restore( + asset_operations: Union["FeatureSetOperations", "FeatureStoreEntityOperations"], + version_operation: Union[ + "FeaturesetVersionsOperations", + "FeaturestoreEntityVersionsOperations", + ], + is_archived: bool, + name: str, + version: str, + **kwargs, +) -> None: + resource_group_name = asset_operations._operation_scope._resource_group_name + workspace_name = asset_operations._workspace_name + + version_resource = version_operation.get( + name=name, + version=version, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + ) + + if version_resource.properties.stage == "Archived" and is_archived: + raise ValidationException( + message="Asset version is already archived: {}:{}".format(name, version), + no_personal_data_message="Asset version is already archived", + target=ErrorTarget.ASSET, + error_category=ErrorCategory.USER_ERROR, + error_type=ValidationErrorType.INVALID_VALUE, + ) + + if version_resource.properties.stage != "Archived" and not is_archived: + raise ValidationException( + message="Cannot restore non-archived asset version: {}:{}".format(name, version), + no_personal_data_message="Asset version is not archived", + target=ErrorTarget.ASSET, + error_category=ErrorCategory.USER_ERROR, + error_type=ValidationErrorType.INVALID_VALUE, + ) + + version_resource.properties.is_archived = is_archived + version_resource.properties.stage = "Archived" if is_archived else "Development" + poller = version_operation.begin_create_or_update( + name=name, + version=version, + resource_group_name=resource_group_name, + workspace_name=workspace_name, + body=version_resource, + **kwargs, + ) + poller.result() + + +def _datetime_to_str(datetime_obj: Union[str, datetime]): + return datetime_obj if isinstance(datetime_obj, str) else datetime_obj.isoformat() diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_func_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_func_utils.py new file mode 100644 index 00000000..0e4b465a --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_func_utils.py @@ -0,0 +1,471 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- +import abc +import logging +import sys +from contextlib import contextmanager +from types import CodeType, FrameType, FunctionType, MethodType +from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union + +from azure.ai.ml._utils.utils import is_bytecode_optimization_enabled + +logger = logging.getLogger(__name__) + + +class PersistentLocalsFunctionBuilder(abc.ABC): + errors = { + "not_callable": "func must be a function or a callable object", + "conflict_argument": "Injected param name __self conflicts with function args {args}", + "not_all_template_separators_used": "Not all template separators are used, " + "please switch to a compatible version of Python.", + "invalid_template": "Provided template functions are invalid in current environment, " + "please switch to a compatible version (3.9 e.g.) of Python " + "and/or check template functions.", + } + injected_param = "__self" + + @classmethod + def make_error(cls, error_name: str, **kwargs) -> str: + """Make error message with error_name and kwargs. + + :param error_name: A key from :attr:`~PersistentLocalsFunctionBuilder.errors` + :type error_name: str + :return: Formatted error message + :rtype: str + """ + return cls.errors[error_name].format(**kwargs) + + @abc.abstractmethod + def _call(self, func, _all_kwargs) -> Tuple[Any, dict]: + raise NotImplementedError() + + def call(self, func, _all_kwargs) -> Tuple[Any, dict]: + """Get outputs and locals in calling func with _all_kwargs. Locals will be used to update node variable names. + + :param func: The function to execute. + :type func: Union[FunctionType, MethodType] + :param _all_kwargs: All kwargs to call self.func. + :type _all_kwargs: typing.Dict[str, typing.Any] + :return: A tuple of outputs and locals. + :rtype: typing.Tuple[typing.Any, typing.Dict] + """ + if isinstance(func, (FunctionType, MethodType)): + pass + elif hasattr(func, "__call__"): + func = func.__call__ + else: + raise TypeError(self.make_error("not_callable")) + + if self.injected_param in func.__code__.co_varnames: + raise ValueError(self.make_error("conflict_argument", args=list(func.__code__.co_varnames))) + + return self._call(func, _all_kwargs) + + +class PersistentLocalsFunctionProfilerBuilder(PersistentLocalsFunctionBuilder): + @staticmethod + @contextmanager + # pylint: disable-next=docstring-missing-return,docstring-missing-rtype + def _replace_sys_profiler(profiler: Callable[[FrameType, str, Any], None]) -> Iterable[None]: + """A context manager which replaces sys profiler to given profiler. + + :param profiler: The profile function. + See https://docs.python.org/3/library/sys.html#sys.setprofile for more information + :type profiler: Callable[[FrameType, str, Any], None] + """ + original_profiler = sys.getprofile() + sys.setprofile(profiler) + try: + yield + finally: + sys.setprofile(original_profiler) + + @staticmethod + def _get_func_variable_tracer( + _locals_data: Dict[str, Any], func_code: CodeType + ) -> Callable[[FrameType, str, Any], None]: + """Get a tracer to trace variable names in dsl.pipeline function. + + :param _locals_data: A dict to save locals data. + :type _locals_data: dict + :param func_code: An code object to compare if current frame is inside user function. + :type func_code: CodeType + :return: A tracing function + :rtype: Callable[[FrameType, str, Any], None] + """ + + def tracer(frame: FrameType, event: str, arg: Any) -> None: # pylint: disable=unused-argument + if frame.f_code == func_code and event == "return": + # Copy the locals of user's dsl function when it returns. + _locals_data.update(frame.f_locals.copy()) + + return tracer + + def _call(self, func, _all_kwargs): + _locals = {} + func_variable_profiler = self._get_func_variable_tracer(_locals, func.__code__) + with self._replace_sys_profiler(func_variable_profiler): + outputs = func(**_all_kwargs) + return outputs, _locals + + +class PersistentLocalsFunction(object): + def __init__( + self, + _func, + *, + _self: Optional[Any] = None, + skip_locals: Optional[List[str]] = None, + ): + """ + :param _func: The function to be wrapped. + :param _self: If original func is a method, _self should be provided, which is the instance of the method. + :param skip_locals: A list of local variables to skip when saving the locals. + """ + self._locals = {} + self._self = _self + # make function an instance method + self._func = MethodType(_func, self) + self._skip_locals = skip_locals + + def __call__(__self, *args, **kwargs): # pylint: disable=no-self-argument + # Use __self in case self is also passed as a named argument in kwargs + __self._locals.clear() + try: + if __self._self: + return __self._func(__self._self, *args, **kwargs) # pylint: disable=not-callable + return __self._func(*args, **kwargs) # pylint: disable=not-callable + finally: + # always pop skip locals even if exception is raised in user code + if __self._skip_locals is not None: + for skip_local in __self._skip_locals: + __self._locals.pop(skip_local, None) + + @property + def locals(self): + return self._locals + + +def _source_template_func(mock_arg): + return mock_arg + + +def _target_template_func(__self, mock_arg): + try: + return mock_arg + finally: + __self._locals = locals().copy() # pylint: disable=protected-access + + +try: + from bytecode import Bytecode, Instr, Label + + class PersistentLocalsFunctionBytecodeBuilder(PersistentLocalsFunctionBuilder): + _template_separators = [] + _template_separators_before_body = [] + _template_separators_after_body = [] + _template_body = [] + _template_tail = None + __initialized = False + + @classmethod + def _split(cls, instructions, separator, n=-1): + cur_start, index, result = 0, 0, [] + while index < len(instructions) - len(separator) + 1: + if cls.is_instr_equal(instructions[index], separator[0]): + for i, template_body_instruction in enumerate(separator): + if not cls.is_instr_equal(instructions[index + i], template_body_instruction): + break + else: + result.append(instructions[cur_start:index]) + cur_start = index + len(separator) + index += len(separator) + if len(result) == n: + break + continue + index += 1 + result.append(instructions[cur_start:]) + if n != -1 and len(result) != n: + msg = "can't split instructions into {} pieces with provided separators".format(n) + raise ValueError(msg) + return result + + @classmethod + def _class_init_impl(cls): + """Override this method to implement different template matching algorithm.""" + cls._template_separators_before_body, cls._template_separators_after_body = cls._split( + cls.get_instructions(_source_template_func), + separator=cls._get_mock_body_instructions(), + n=2, + ) + # use None to indicate the body + cls._template_separators = ( + cls._template_separators_before_body + [None] + cls._template_separators_after_body + ) + + cls._template_body = cls._split_instructions_based_on_template( + cls.get_instructions(_target_template_func), + remove_mock_body=True, + ) + cls._template_tail = cls._template_body.pop() + if len(cls._template_body) != len(cls._template_body): + raise ValueError(cls.make_error("invalid_template")) + + @classmethod + def __class_init(cls): + if cls.__initialized: + return + + cls._class_init_impl() + + cls.__initialized = True + + def __init__(self): + self.__class_init() + + # region methods depending on package bytecode + @classmethod + def get_instructions(cls, func): + return list(Bytecode.from_code(func.__code__)) + + @classmethod + def is_instr_equal(cls, instr1: Instr, instr2: Instr) -> bool: + if instr1 is None and instr2 is None: + return True + if instr1 is None or instr2 is None: + return False + if instr1.__class__ != instr2.__class__: + return False + if isinstance(instr1, Instr): + if isinstance(instr1.arg, Label) and isinstance(instr2.arg, Label): + return True + return instr1.opcode == instr2.opcode and instr1.arg == instr2.arg + # objects like Label and TryBegin + return True + + @classmethod + def is_instructions_equal(cls, instructions1: List[Instr], instructions2: List[Instr]) -> bool: + if len(instructions1) != len(instructions2): + return False + for instr1, instr2 in zip(instructions1, instructions2): + if not cls.is_instr_equal(instr1, instr2): + return False + return True + + def _create_code(self, instructions: List[Instr], base_func: Union[FunctionType, MethodType]) -> CodeType: + """Create the base bytecode for the function to be generated. + + Will keep information of the function, such as name, globals, etc., but skip all instructions. + + :param instructions: The list of instructions. Used to replace the instructions in base_func + :type instructions: List[Instr] + :param base_func: A function that provides base metadata (name, globals, etc...). Instructions will not + be kept + :type base_func: Union[FunctionType, MethodType] + :return: Generated code + :rtype: CodeType + """ + fn_code = Bytecode.from_code(base_func.__code__) + fn_code.clear() + fn_code.extend(instructions) + fn_code.argcount += 1 + fn_code.argnames.insert(0, self.injected_param) + return fn_code.to_code() + + @classmethod + def _get_mock_body_instructions(cls): + return [Instr("LOAD_FAST", "mock_arg")] + + # endregion + + @classmethod + def _get_pieces(cls, instructions: List[Instr], separators: List[Instr]) -> List[List[Instr]]: + """Split the instructions into pieces by the separators. + Note that separators is a list of instructions. For example, + instructions: [I3, I1, I2, I3, I1, I3, I1, I2, I3] + separators: [I1, I2] + result: [[I3], [I3, I1, I3], [I3]] + + :param instructions: The list of instructions to split + :type instructions: List[instr] + :param separators: The sequence of Instr to use as a delimiter + :type separators: List[Instr] + :return: A sublists of instructions that were delimited by separators + :rtype: List[List[Instr]] + """ + separator_iter = iter(separators) + + def get_next_separator(): + try: + while True: + separator = next(separator_iter) + if separator is not None: + return separator + except StopIteration: + return None + + pieces = [] + last_piece = [] + cur_separator = get_next_separator() + for instr in instructions: + if cls.is_instr_equal(instr, cur_separator): + # skip the separator + pieces.append(last_piece) + cur_separator = get_next_separator() + last_piece = [] + else: + last_piece.append(instr) + pieces.append(last_piece) + + if cur_separator is not None: + raise ValueError(cls.make_error("not_all_template_separators_used")) + + return pieces + + @classmethod + def _split_instructions_based_on_template( + cls, + instructions: List[Instr], + *, + remove_mock_body: bool = False, + ) -> List[List[Instr]]: + """Split instructions into several pieces by separators. + For example, in Python 3.11, the template source instructions will be: + + .. code-block:: python + + [ + Instr('RESUME', 0), # initial instruction shared by all functions + Instr('LOAD_FAST', 'mock_arg'), # the body execution instruction + Instr('RETURN_VALUE'), # the return instruction shared by all functions + ] + + Then the separators before body will be: + + .. code-block:: python + + [ + Instr('RESUME', 0), + ] + + And the separators after body will be: + + .. code-block:: python + + [ + Instr('RETURN_VALUE'), + ] + + For passed in instructions, we will split them with separators from beginning (the first RESUME) and + with reversed_separators from end (the last RETURN_VALUE). + + :param instructions: The instructions to split + :type instructions: List[instr] + :keyword remove_mock_body: Whether to remove the mock body. Defaults to False + :paramtype remove_mock_body: bool + :return: The split instructions + :rtype: List[List[Instr]] + """ + if remove_mock_body: + # this parameter should be set as True only when processing the template target function, + # when we should ignore the mock body + pieces = cls._get_pieces( + instructions, cls._template_separators_before_body + cls._get_mock_body_instructions() + ) + else: + pieces = cls._get_pieces(instructions, cls._template_separators_before_body) + + reversed_pieces = cls._get_pieces(reversed(pieces.pop()), reversed(cls._template_separators_after_body)) + + while reversed_pieces: + pieces.append(list(reversed(reversed_pieces.pop()))) + + return pieces + + def _build_instructions(self, func: Union[FunctionType, MethodType]) -> List[Instr]: + generated_instructions = [] + + for template_piece, input_piece, separator in zip( + self._template_body, + self._split_instructions_based_on_template(self.get_instructions(func)), + self._template_separators, + ): + generated_instructions.extend(template_piece) + generated_instructions.extend(input_piece) + if separator is not None: + generated_instructions.append(separator) + generated_instructions.extend(self._template_tail) + return generated_instructions + + def _build_func(self, func: Union[FunctionType, MethodType]) -> PersistentLocalsFunction: + """Build a persistent locals function from the given function. Use bytecode injection to add try...finally + statement around code to persistent the locals in the function. + + It will change the func bytecode in this way: + + .. code-block:: python + + def func(__self, *func_args): + try: + the func code... + finally: + __self.locals = locals().copy() + + You can get the locals in func by this code: + + .. code-block:: python + + builder = PersistentLocalsFunctionBuilder() + persistent_locals_func = builder.build(your_func) + # Execute your func + result = persistent_locals_func(*args) + # Get the locals in the func. + func_locals = persistent_locals_func.locals + + :param func: The function to modify + :type func: Union[FunctionType, MethodType] + :return: The built persistent locals function + :rtype: PersistentLocalsFunction + """ + generated_func = FunctionType( + self._create_code(self._build_instructions(func), func), + func.__globals__, + func.__name__, + func.__defaults__, + func.__closure__, + ) + return PersistentLocalsFunction( + generated_func, + _self=func.__self__ if isinstance(func, MethodType) else None, + skip_locals=[self.injected_param], + ) + + def _call(self, func, _all_kwargs) -> Tuple[Any, dict]: + persistent_func = self._build_func(func) + outputs = persistent_func(**_all_kwargs) + return outputs, persistent_func.locals + +except ImportError: + # Fall back to the profiler implementation + class PersistentLocalsFunctionBytecodeBuilder(PersistentLocalsFunctionProfilerBuilder): + pass + + +def _get_persistent_locals_builder() -> PersistentLocalsFunctionBuilder: + if is_bytecode_optimization_enabled(): + return PersistentLocalsFunctionBytecodeBuilder() + return PersistentLocalsFunctionProfilerBuilder() + + +def get_outputs_and_locals(func, _all_kwargs): + """Get outputs and locals from self.func. Locals will be used to update node variable names. + + :param func: The function to execute. + :type func: Union[FunctionType, MethodType] + :param _all_kwargs: All kwargs to call self.func. + :type _all_kwargs: typing.Dict[str, typing.Any] + :return: A tuple of outputs and locals. + :rtype: typing.Tuple[typing.Dict, typing.Dict] + """ + return _get_persistent_locals_builder().call(func, _all_kwargs) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_html_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_html_utils.py new file mode 100644 index 00000000..faf6a406 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_html_utils.py @@ -0,0 +1,155 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import logging +from collections import OrderedDict +from datetime import datetime, timedelta +from html import escape + +SUPPORTED_VALUE_TYPE_TUPLE = (int, float, str, datetime, timedelta) +TABLE_FMT = '<table style="width:100%">{0}</table>' +ROW_FMT = "<tr>{0}</tr>" +HEADER_FMT = "<th>{0}</th>" +DATA_FMT = "<td>{0}</td>" +# target="_blank" opens in new tab, rel="noopener" is for perf + security +LINK_FMT = '<a href="{0}" target="_blank" rel="noopener">{1}</a>' + + +def convert_dict_to_table(object_to_convert): + # Case 1: All non-collection values -> table of 1 row + # Case 2: All collection values, lens eq N -> assert lengths eq, table of N rows + # Case 3: collection and non-collection values -> table of 1 row, collections nest + # Case 4: All collection values, lens unequal -> table of 1 row, each is nested collection? + + if not isinstance(object_to_convert, dict): + raise AssertionError("Expected a dict or subclass, got {0}".format(type(object_to_convert))) + + if len(object_to_convert) == 0: + return "" + + ordered_obj = OrderedDict(object_to_convert) + + def is_collection_type(val): + return hasattr(val, "__len__") and not isinstance(val, str) + + is_collection = [is_collection_type(value) for value in ordered_obj.values()] + + all_rows = [get_header_row_string(ordered_obj.keys())] + + def values_to_data_row(values): + cells = [to_html(value) for value in values] + return get_data_row_string(cells) + + if all(is_collection): + # Cases 2 and 4 + length = len(list(ordered_obj.values)[0]) + if any(len(v) != length for v in ordered_obj.values()): + # Case 4 + logging.warning("Uneven column lengths in table conversion") + all_rows.append(values_to_data_row(ordered_obj.values())) + + else: + # Case 2 - sad transpose + for i in range(length): + value_list = [val[i] for val in ordered_obj.values()] + all_rows.append(values_to_data_row(value_list)) + + else: + # Cases 1 and 3 + # Table of 1 row of values or mixed types, table of 1 row + all_rows.append(values_to_data_row(ordered_obj.values())) + + return table_from_html_rows(all_rows) + + +def convert_list_to_table(object_to_convert): + if not isinstance(object_to_convert, list): + raise AssertionError("Expected a list or subclass, got {0}".format(type(object_to_convert))) + + if len(object_to_convert) == 0: + return "" + + all_values = [to_html(element) for element in object_to_convert] + all_rows = [get_data_row_string([element]) for element in all_values] + return table_from_html_rows(all_rows) + + +# Mapping from complex type to HTML converters +# Unspecified types default to convert_value +_type_to_converter = {list: convert_list_to_table, dict: convert_dict_to_table} + + +def to_html(object_to_convert): + candidate_converters = [k for k in _type_to_converter if isinstance(object_to_convert, k)] + + if len(candidate_converters) == 0: + converter = convert_value + elif len(candidate_converters) == 1: + converter = _type_to_converter[candidate_converters[0]] + else: + logging.warning("Multiple candidate converters found for type %s", type(object_to_convert)) + converter = convert_value + + converted_value = converter(object_to_convert) + return converted_value + + +def is_string_link(string: str) -> bool: + return isinstance(string, str) and string.strip().lower().startswith("http") + + +def make_link(link_string: str, link_text: str = "") -> str: + if not link_text: # Actually want truthy string + link_text = "Link" + return LINK_FMT.format(escape(link_string), link_text) + + +def convert_value(value: str) -> str: + if value is None: + return "" + if is_string_link(value): + return make_link(value) + if not isinstance(value, SUPPORTED_VALUE_TYPE_TUPLE): + logging.warning("Unsupported type %s for html, converting", type(value)) + + # TODO: Figure out a good escaping story here right now it breaks existing tags + return str(value) + + +def get_header_row_string(column_headers): + headers = [HEADER_FMT.format(header) for header in column_headers] + return ROW_FMT.format("".join(headers)) + + +def get_data_row_string(data_values): + data = [DATA_FMT.format(datum) for datum in data_values] + return ROW_FMT.format("".join(data)) + + +def table_from_html_rows(list_of_rows): + # type/: (List[str]) -> str + return TABLE_FMT.format("".join(list_of_rows)) + + +def to_formatted_html_table(rows, header): + html = ["""<table style="width:100%; border:2px solid black" >"""] + if header is not None: + html_row = "</td><td>".join(column for column in header) + html.append( + """<tr style="font-weight:bold; border-bottom:1pt solid black; border-right: 1pt solid black; + text-align: center"><td>{}</td></tr>""".format( + html_row + ) + ) + + for row in rows: + html_row = "</td><td>".join(str(value) for value in row) + html.append( + """<tr style="width:100%; word-wrap: break-word; border-bottom:1pt solid black; + text-align: center"><td>{}</td></tr>""".format( + html_row + ) + ) + html.append("</table>") + return "".join(html) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_http_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_http_utils.py new file mode 100644 index 00000000..ddaae25e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_http_utils.py @@ -0,0 +1,180 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + + +from functools import wraps +from typing import Any, Callable, Optional + +from typing_extensions import Concatenate, ParamSpec, Self + +from azure.core.configuration import Configuration +from azure.core.pipeline import Pipeline +from azure.core.pipeline.policies import ( + CustomHookPolicy, + HeadersPolicy, + HttpLoggingPolicy, + NetworkTraceLoggingPolicy, + ProxyPolicy, + RedirectPolicy, + RetryPolicy, + UserAgentPolicy, +) +from azure.core.pipeline.transport import ( # pylint: disable=non-abstract-transport-import,no-name-in-module + HttpTransport, + RequestsTransport, +) +from azure.core.rest import HttpRequest, HttpResponse + + +def _request_function(f: Callable[["HttpPipeline"], None]): + """A decorator that provides the implementation for the request-style convenience functions of the HttpPipeline + class. + + :param Callable[[], None] f: A function whose name will be used as the http + request method + :return: An HTTP request function + :rtype: Callable + """ + + # This is a hack to provide richer typing for the decorated function + # The outer _ function allows us to pattern match on the parameter types + # of HttpRequest and forward those types to the decorated function + P = ParamSpec("P") + + def _(_: Callable[Concatenate[str, P], Any] = HttpRequest): + @wraps(f) + # pylint: disable-next=docstring-missing-param + def decorated(self: "HttpPipeline", *args: P.args, **kwargs: P.kwargs) -> HttpResponse: + """A function that sends an HTTP request and returns the response. + + Accepts the same parameters as azure.core.rest.HttpRequest, except for the method. + All other kwargs are forwarded to azure.core.Pipeline.run + + :return: The request response + :rtype: HttpResponse + """ + request = HttpRequest( + f.__name__.upper(), + *args, + params=kwargs.pop("params", None), + headers=kwargs.pop("headers", None), + json=kwargs.pop("json", None), + content=kwargs.pop("content", None), + data=kwargs.pop("data", None), + files=kwargs.pop("files", None), + ) + + return self.run(request, **kwargs).http_response + + return decorated + + return _() + + +class HttpPipeline(Pipeline): + """A *very* thin wrapper over azure.core.pipeline.Pipeline that facilitates sending miscellaneous http requests by + adding: + + * A requests-style api for sending http requests + * Facilities for populating policies for the client, include defaults, + and re-using policies from an existing client. + """ + + def __init__( + self, + *, + transport: Optional[HttpTransport] = None, + config: Optional[Configuration] = None, + user_agent_policy: Optional[UserAgentPolicy] = None, + headers_policy: Optional[HeadersPolicy] = None, + proxy_policy: Optional[ProxyPolicy] = None, + logging_policy: Optional[NetworkTraceLoggingPolicy] = None, + http_logging_policy: Optional[HttpLoggingPolicy] = None, + retry_policy: Optional[RetryPolicy] = None, + custom_hook_policy: Optional[CustomHookPolicy] = None, + redirect_policy: Optional[RedirectPolicy] = None, + **kwargs + ): + """ + + :param HttpTransport transport: Http Transport used for requests, defaults to RequestsTransport + :param Configuration config: + :param UserAgentPolicy user_agent_policy: + :param HeadersPolicy headers_policy: + :param ProxyPolicy proxy_policy: + :param NetworkTraceLoggingPolicy logging_policy: + :param HttpLoggingPolicy http_logging_policy: + :param RetryPolicy retry_policy: + :param CustomHookPolicy custom_hook_policy: + :param RedirectPolicy redirect_policy: + """ + config = config or Configuration() + config.headers_policy = headers_policy or config.headers_policy or HeadersPolicy(**kwargs) + config.proxy_policy = proxy_policy or config.proxy_policy or ProxyPolicy(**kwargs) + config.redirect_policy = redirect_policy or config.redirect_policy or RedirectPolicy(**kwargs) + config.retry_policy = retry_policy or config.retry_policy or RetryPolicy(**kwargs) + config.custom_hook_policy = custom_hook_policy or config.custom_hook_policy or CustomHookPolicy(**kwargs) + config.logging_policy = logging_policy or config.logging_policy or NetworkTraceLoggingPolicy(**kwargs) + config.http_logging_policy = http_logging_policy or config.http_logging_policy or HttpLoggingPolicy(**kwargs) + config.user_agent_policy = user_agent_policy or config.user_agent_policy or UserAgentPolicy(**kwargs) + config.polling_interval = kwargs.get("polling_interval", 30) + + super().__init__( + # RequestsTransport normally should not be imported outside of azure.core, since transports + # are meant to be user configurable. + # RequestsTransport is only used in this file as the default transport when not user specified. + transport=transport or RequestsTransport(**kwargs), + policies=[ + config.headers_policy, + config.user_agent_policy, + config.proxy_policy, + config.redirect_policy, + config.retry_policy, + config.authentication_policy, + config.custom_hook_policy, + config.logging_policy, + ], + ) + + self._config = config + + def with_policies(self, **kwargs) -> Self: + """A named constructor which facilitates creating a new pipeline using an existing one as a base. + + Accepts the same parameters as __init__ + + :return: new Pipeline object with combined config of current object + and specified overrides + :rtype: Self + """ + cls = self.__class__ + return cls(config=self._config, transport=kwargs.pop("transport", self._transport), **kwargs) + + @_request_function + def delete(self) -> None: + """Sends a DELETE request.""" + + @_request_function + def get(self) -> None: + """Sends a GET request.""" + + @_request_function + def head(self) -> None: + """Sends a HEAD request.""" + + @_request_function + def options(self) -> None: + """Sends a OPTIONS request.""" + + @_request_function + def patch(self) -> None: + """Sends a PATCH request.""" + + @_request_function + def post(self) -> None: + """Sends a POST request.""" + + @_request_function + def put(self) -> None: + """Sends a PUT request.""" diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_logger_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_logger_utils.py new file mode 100644 index 00000000..68a90aca --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_logger_utils.py @@ -0,0 +1,62 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import logging +import sys + +from opentelemetry import trace + +from azure.ai.ml._telemetry.logging_handler import AML_INTERNAL_LOGGER_NAMESPACE + + +def initialize_logger_info(module_logger: logging.Logger, terminator="\n") -> None: + """Initializes the logger with INFO level and adds a StreamHandler to the logger. + + :param module_logger: The logger to be initialized. + :type module_logger: logging.Logger + :param terminator: The line terminator for the StreamHandler. Defaults to a newline character. + :type terminator: str + :return: None + """ + module_logger.setLevel(logging.INFO) + module_logger.propagate = False + handler = logging.StreamHandler(sys.stderr) + handler.setLevel(logging.INFO) + handler.terminator = terminator + handler.flush = sys.stderr.flush + module_logger.addHandler(handler) + + +tracer = trace.get_tracer(AML_INTERNAL_LOGGER_NAMESPACE) + + +class OpsLogger: + """ + A logger class for managing logging and tracing operations within a package. + This class initializes loggers and tracers for a specified package, and provides methods to update logging filters. + """ + + def __init__(self, name: str): + """ + This constructor sets up the package logger, module logger, and tracer for the given package name. + :param name: The name of the package for which the logger is being initialized. + :type name: str + """ + self.package_logger: logging.Logger = logging.getLogger(AML_INTERNAL_LOGGER_NAMESPACE).getChild(name) + self.package_logger.propagate = True + self.package_tracer = tracer + self.module_logger = logging.getLogger(name) + self.custom_dimensions = {} + + def update_filter(self) -> None: + """ + Update the logging filter for the package logger. + This method attaches the filter from the parent logger to the package logger, + as the parent's filter is not automatically propagated to the child logger. + + :return: None + """ + # Attach filter explicitly as parent logger's filter is not propagated to child logger + if self.package_logger.parent.filters: + self.package_logger.addFilter(self.package_logger.parent.filters[0]) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_package_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_package_utils.py new file mode 100644 index 00000000..f50a6140 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_package_utils.py @@ -0,0 +1,99 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +# pylint: disable=try-except-raise + +import logging + + +from azure.ai.ml.entities import BatchDeployment, OnlineDeployment, Deployment +from azure.ai.ml._restclient.v2023_04_01_preview.models import ( + PackageRequest, + CodeConfiguration, + BaseEnvironmentId, + AzureMLOnlineInferencingServer, + AzureMLBatchInferencingServer, +) +from azure.ai.ml._restclient.v2021_10_01_dataplanepreview.models import ( + PackageRequest as DataPlanePackageRequest, +) +from azure.ai.ml.constants._common import REGISTRY_URI_FORMAT + +from azure.ai.ml._utils._logger_utils import initialize_logger_info + +module_logger = logging.getLogger(__name__) +initialize_logger_info(module_logger, terminator="") + + +def package_deployment(deployment: Deployment, model_ops) -> Deployment: + model_str = deployment.model + model_version = model_str.split("/")[-1] + model_name = model_str.split("/")[-3] + target_environment_name = "packaged-env" + + if deployment.code_configuration: + code_configuration = CodeConfiguration( + code_id=deployment.code_configuration.code, + scoring_script=deployment.code_configuration.scoring_script, + ) + else: + code_configuration = None + + if isinstance(deployment, OnlineDeployment): + inferencing_server = AzureMLOnlineInferencingServer(code_configuration=code_configuration) + elif isinstance(deployment, BatchDeployment): + inferencing_server = AzureMLBatchInferencingServer(code_configuration=code_configuration) + else: + inferencing_server = None + + if deployment.environment: + base_environment_source = BaseEnvironmentId( + base_environment_source_type="EnvironmentAsset", resource_id=deployment.environment + ) + else: + base_environment_source = None + + package_request = ( + PackageRequest( + target_environment_name=target_environment_name, + base_environment_source=base_environment_source, + inferencing_server=inferencing_server, + ) + if not model_str.startswith(REGISTRY_URI_FORMAT) + else DataPlanePackageRequest( + inferencing_server=inferencing_server, + target_environment_id=target_environment_name, + base_environment_source=base_environment_source, + ) + ) + + if deployment.environment: + if not model_str.startswith(REGISTRY_URI_FORMAT): + package_request.base_environment_source.resource_id = "azureml:/" + deployment.environment + else: + package_request.base_environment_source.resource_id = deployment.environment + if deployment.code_configuration: + if not deployment.code_configuration.code.startswith(REGISTRY_URI_FORMAT): + package_request.inferencing_server.code_configuration.code_id = ( + "azureml:/" + deployment.code_configuration.code + ) + else: + package_request.inferencing_server.code_configuration.code_id = deployment.code_configuration.code + + try: + packaged_env = model_ops.package( + model_name, + model_version, + package_request=package_request, + skip_to_rest=True, + ) + if not model_str.startswith(REGISTRY_URI_FORMAT): + deployment.environment = packaged_env.id + else: + deployment.environment = packaged_env.target_environment_id + deployment.model = None + deployment.code_configuration = None + except Exception: + raise + return deployment diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_pathspec.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_pathspec.py new file mode 100644 index 00000000..a9a18239 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_pathspec.py @@ -0,0 +1,587 @@ +# --------------------------------------------------------- +# Copyright (c) 2013-2022 Caleb P. Burns credits dahlia <https://github.com/dahlia> +# Licensed under the MPLv2 License. See License.txt in the project root for +# license information. +# --------------------------------------------------------- +""" +This file code has been vendored from pathspec repo. +Please do not edit it, unless really necessary +""" +import dataclasses +import os +import posixpath +import re +import warnings +from typing import Any, AnyStr, Iterable +from typing import Match as MatchHint +from typing import Optional +from typing import Pattern as PatternHint +from typing import Tuple, Union + +NORMALIZE_PATH_SEPS = [sep for sep in [os.sep, os.altsep] if sep and sep != posixpath.sep] + +# The encoding to use when parsing a byte string pattern. +# This provides the base definition for patterns. +_BYTES_ENCODING = "latin1" + + +class Pattern(object): + """ + The :class:`Pattern` class is the abstract definition of a pattern. + """ + + # Make the class dict-less. + __slots__ = ("include",) + + def __init__(self, include: Optional[bool]) -> None: + """ + Initializes the :class:`Pattern` instance. + *include* (:class:`bool` or :data:`None`) is whether the matched + files should be included (:data:`True`), excluded (:data:`False`), + or is a null-operation (:data:`None`). + """ + + self.include = include + """ + *include* (:class:`bool` or :data:`None`) is whether the matched + files should be included (:data:`True`), excluded (:data:`False`), + or is a null-operation (:data:`None`). + """ + + def match(self, files: Iterable[str]) -> Iterable[str]: + """Matches this pattern against the specified files. + + :param files: Contains each file relative to the root directory (e.g. :data:`"relative/path/to/file"`). + :type files: Iterable[str] + :return: The matched file paths + :rtype: Iterable[str] + + .. deprecated:: + + This method is no longer used and has been replaced by :meth:`.match_file`. Use the :meth:`.match_file` + method with a loop for similar results. + """ + warnings.warn( + ( + "{0.__module__}.{0.__qualname__}.match() is deprecated. Use " + "{0.__module__}.{0.__qualname__}.match_file() with a loop for " + "similar results." + ).format(self.__class__), + DeprecationWarning, + stacklevel=2, + ) + + for file in files: + if self.match_file(file) is not None: + yield file + + def match_file(self, file: str) -> Optional[Any]: + """Matches this pattern against the specified file. + + :param file: The normalized file path to match against. + :type file: str + :return: Returns the match result if *file* matched; otherwise, :data:`None`. + :rtype: Optional[Any] + """ + raise NotImplementedError( + ("{0.__module__}.{0.__qualname__} must override match_file().").format(self.__class__) + ) + + +class RegexPattern(Pattern): + """ + The :class:`RegexPattern` class is an implementation of a pattern + using regular expressions. + """ + + # Keep the class dict-less. + __slots__ = ("regex",) + + def __init__( + self, + pattern: Union[AnyStr, PatternHint], + include: Optional[bool] = None, + ) -> None: + """ + Initializes the :class:`RegexPattern` instance. + *pattern* (:class:`str`, :class:`bytes`, :class:`re.Pattern`, or + :data:`None`) is the pattern to compile into a regular expression. + *include* (:class:`bool` or :data:`None`) must be :data:`None` + unless *pattern* is a precompiled regular expression (:class:`re.Pattern`) + in which case it is whether matched files should be included + (:data:`True`), excluded (:data:`False`), or is a null operation + (:data:`None`). + .. NOTE:: Subclasses do not need to support the *include* + parameter. + """ + + if isinstance(pattern, (str, bytes)): + assert include is None, ("include:{!r} must be null when pattern:{!r} is a string.").format( + include, pattern + ) + regex, include = self.pattern_to_regex(pattern) + # NOTE: Make sure to allow a null regular expression to be + # returned for a null-operation. + if include is not None: + regex = re.compile(regex) + + elif pattern is not None and hasattr(pattern, "match"): + # Assume pattern is a precompiled regular expression. + # - NOTE: Used specified *include*. + regex = pattern + + elif pattern is None: + # NOTE: Make sure to allow a null pattern to be passed for a + # null-operation. + assert include is None, ("include:{!r} must be null when pattern:{!r} is null.").format(include, pattern) + + else: + raise TypeError("pattern:{!r} is not a string, re.Pattern, or None.".format(pattern)) + + super(RegexPattern, self).__init__(include) + + self.regex: PatternHint = regex + """ + *regex* (:class:`re.Pattern`) is the regular expression for the + pattern. + """ + + def __eq__(self, other: "RegexPattern") -> bool: + """Tests the equality of this regex pattern with *other* + + :param other: The regex pattern to test against + :type other: RegexPattern + :return: Return True if :attr:`~Pattern.include` and :attr:`~RegexPattern.regex` + are equal. False otherwise. + :rtype: bool + """ + if isinstance(other, RegexPattern): + return self.include == other.include and self.regex == other.regex + return NotImplemented + + def match_file(self, file: str) -> Optional["RegexMatchResult"]: + """Matches this pattern against the specified file. + + :param file: File relative to the root directory (e.g., "relative/path/to/file"). + :type file: str + :return: Returns the match result (:class:`RegexMatchResult`) if *file* + matched; otherwise, :data:`None`. + :rtype: Optional[RegexMatchResult] + """ + if self.include is not None: + match = self.regex.match(file) + if match is not None: + return RegexMatchResult(match) + + return None + + @classmethod + def pattern_to_regex(cls, pattern: str) -> Tuple[str, bool]: + """Convert the pattern into an uncompiled regular expression. + + :param pattern: The pattern to convert into a regular expression. + :type pattern: str + :return: Returns the uncompiled regular expression (:class:`str` or :data:`None`), + and whether matched files should be included (:data:`True`), + excluded (:data:`False`), or is a null-operation (:data:`None`). + :rtype: Tuple[str, bool] + + .. NOTE:: + + The default implementation simply returns *pattern* and :data:`True`. + """ + return pattern, True + + +@dataclasses.dataclass() +class RegexMatchResult(object): + """ + The :class:`RegexMatchResult` data class is used to return information + about the matched regular expression. + """ + + # Keep the class dict-less. + __slots__ = ("match",) + + match: MatchHint + """ + *match* (:class:`re.Match`) is the regex match result. + """ + + +class GitWildMatchPatternError(ValueError): + """ + The :class:`GitWildMatchPatternError` indicates an invalid git wild match + pattern. + """ + + +class GitWildMatchPattern(RegexPattern): + """ + The :class:`GitWildMatchPattern` class represents a compiled Git + wildmatch pattern. + """ + + # Keep the dict-less class hierarchy. + __slots__ = () + + @classmethod + # pylint: disable=too-many-branches,too-many-statements + def pattern_to_regex( + cls, + pattern: AnyStr, + ) -> Tuple[Optional[AnyStr], Optional[bool]]: + """Convert the pattern into a regular expression. + + :param pattern: Pattern to convert into a regular expression. + :type pattern: AnyStr + :return: A 2-tuple of: + * the uncompiled regular expression (:class:`str`, :class:`bytes`, + or :data:`None`) + * whether matched files should be included (:data:`True`), excluded (:data:`False`), or if it is a + null-operation (:data:`None`). + :rtype: Tuple[Optional[AnyStr], Optional[bool]] + """ + if isinstance(pattern, str): + return_type = str + elif isinstance(pattern, bytes): + return_type = bytes + pattern = pattern.decode(_BYTES_ENCODING) + else: + raise TypeError(f"pattern:{pattern!r} is not a unicode or byte string.") + + original_pattern = pattern + pattern = pattern.strip() + + if pattern.startswith("#"): + # A pattern starting with a hash ('#') serves as a comment + # (neither includes nor excludes files). Escape the hash with a + # back-slash to match a literal hash (i.e., '\#'). + regex = None + include = None + + elif pattern == "/": + # EDGE CASE: According to `git check-ignore` (v2.4.1), a single + # '/' does not match any file. + regex = None + include = None + + elif pattern: + if pattern.startswith("!"): + # A pattern starting with an exclamation mark ('!') negates the + # pattern (exclude instead of include). Escape the exclamation + # mark with a back-slash to match a literal exclamation mark + # (i.e., '\!'). + include = False + # Remove leading exclamation mark. + pattern = pattern[1:] + else: + include = True + + # Allow a regex override for edge cases that cannot be handled + # through normalization. + override_regex = None + + # Split pattern into segments. + pattern_segs = pattern.split("/") + + # Normalize pattern to make processing easier. + + # EDGE CASE: Deal with duplicate double-asterisk sequences. + # Collapse each sequence down to one double-asterisk. Iterate over + # the segments in reverse and remove the duplicate double + # asterisks as we go. + for i in range(len(pattern_segs) - 1, 0, -1): + prev = pattern_segs[i - 1] + seg = pattern_segs[i] + if prev == "**" and seg == "**": + del pattern_segs[i] + + if len(pattern_segs) == 2 and pattern_segs[0] == "**" and not pattern_segs[1]: + # EDGE CASE: The '**/' pattern should match everything except + # individual files in the root directory. This case cannot be + # adequately handled through normalization. Use the override. + override_regex = "^.+(?P<ps_d>/).*$" + + if not pattern_segs[0]: + # A pattern beginning with a slash ('/') will only match paths + # directly on the root directory instead of any descendant + # paths. So, remove empty first segment to make pattern relative + # to root. + del pattern_segs[0] + + elif len(pattern_segs) == 1 or (len(pattern_segs) == 2 and not pattern_segs[1]): + # A single pattern without a beginning slash ('/') will match + # any descendant path. This is equivalent to "**/{pattern}". So, + # prepend with double-asterisks to make pattern relative to + # root. + # EDGE CASE: This also holds for a single pattern with a + # trailing slash (e.g. dir/). + if pattern_segs[0] != "**": + pattern_segs.insert(0, "**") + + else: + # EDGE CASE: A pattern without a beginning slash ('/') but + # contains at least one prepended directory (e.g. + # "dir/{pattern}") should not match "**/dir/{pattern}", + # according to `git check-ignore` (v2.4.1). + pass + + if not pattern_segs: + # After resolving the edge cases, we end up with no pattern at + # all. This must be because the pattern is invalid. + raise GitWildMatchPatternError(f"Invalid git pattern: {original_pattern!r}") + + if not pattern_segs[-1] and len(pattern_segs) > 1: + # A pattern ending with a slash ('/') will match all descendant + # paths if it is a directory but not if it is a regular file. + # This is equivalent to "{pattern}/**". So, set last segment to + # a double-asterisk to include all descendants. + pattern_segs[-1] = "**" + + if override_regex is None: + # Build regular expression from pattern. + output = ["^"] + need_slash = False + end = len(pattern_segs) - 1 + for i, seg in enumerate(pattern_segs): + if seg == "**": + if i == 0 and i == end: + # A pattern consisting solely of double-asterisks ('**') + # will match every path. + output.append(".+") + elif i == 0: + # A normalized pattern beginning with double-asterisks + # ('**') will match any leading path segments. + output.append("(?:.+/)?") + need_slash = False + elif i == end: + # A normalized pattern ending with double-asterisks ('**') + # will match any trailing path segments. + output.append("(?P<ps_d>/).*") + else: + # A pattern with inner double-asterisks ('**') will match + # multiple (or zero) inner path segments. + output.append("(?:/.+)?") + need_slash = True + + elif seg == "*": + # Match single path segment. + if need_slash: + output.append("/") + + output.append("[^/]+") + + if i == end: + # A pattern ending without a slash ('/') will match a file + # or a directory (with paths underneath it). E.g., "foo" + # matches "foo", "foo/bar", "foo/bar/baz", etc. + output.append("(?:(?P<ps_d>/).*)?") + + need_slash = True + + else: + # Match segment glob pattern. + if need_slash: + output.append("/") + + try: + output.append(cls._translate_segment_glob(seg)) + except ValueError as e: + raise GitWildMatchPatternError(f"Invalid git pattern: {original_pattern!r}") from e + + if i == end: + # A pattern ending without a slash ('/') will match a file + # or a directory (with paths underneath it). E.g., "foo" + # matches "foo", "foo/bar", "foo/bar/baz", etc. + output.append("(?:(?P<ps_d>/).*)?") + + need_slash = True + + output.append("$") + regex = "".join(output) + + else: + # Use regex override. + regex = override_regex + + else: + # A blank pattern is a null-operation (neither includes nor + # excludes files). + regex = None + include = None + + if regex is not None and return_type is bytes: + regex = regex.encode(_BYTES_ENCODING) + + return regex, include + + @staticmethod + def _translate_segment_glob(pattern: str) -> str: + """Translates the glob pattern to a regular expression. This is used in + the constructor to translate a path segment glob pattern to its + corresponding regular expression. + + :param pattern: The glob pattern. + :type pattern: str + :return: The regular expression + :rtype: str + """ + # NOTE: This is derived from `fnmatch.translate()` and is similar to + # the POSIX function `fnmatch()` with the `FNM_PATHNAME` flag set. + + escape = False + regex = "" + i, end = 0, len(pattern) + while i < end: + # Get next character. + char = pattern[i] + i += 1 + + if escape: + # Escape the character. + escape = False + regex += re.escape(char) + + elif char == "\\": + # Escape character, escape next character. + escape = True + + elif char == "*": + # Multi-character wildcard. Match any string (except slashes), + # including an empty string. + regex += "[^/]*" + + elif char == "?": + # Single-character wildcard. Match any single character (except + # a slash). + regex += "[^/]" + + elif char == "[": + # Bracket expression wildcard. Except for the beginning + # exclamation mark, the whole bracket expression can be used + # directly as regex but we have to find where the expression + # ends. + # - "[][!]" matches ']', '[' and '!'. + # - "[]-]" matches ']' and '-'. + # - "[!]a-]" matches any character except ']', 'a' and '-'. + j = i + # Pass back expression negation. + if j < end and pattern[j] == "!": + j += 1 + # Pass first closing bracket if it is at the beginning of the + # expression. + if j < end and pattern[j] == "]": + j += 1 + # Find closing bracket. Stop once we reach the end or find it. + while j < end and pattern[j] != "]": + j += 1 + + if j < end: + # Found end of bracket expression. Increment j to be one past + # the closing bracket: + # + # [...] + # ^ ^ + # i j + # + j += 1 + expr = "[" + + if pattern[i] == "!": + # Bracket expression needs to be negated. + expr += "^" + i += 1 + elif pattern[i] == "^": + # POSIX declares that the regex bracket expression negation + # "[^...]" is undefined in a glob pattern. Python's + # `fnmatch.translate()` escapes the caret ('^') as a + # literal. To maintain consistency with undefined behavior, + # I am escaping the '^' as well. + expr += "\\^" + i += 1 + + # Build regex bracket expression. Escape slashes so they are + # treated as literal slashes by regex as defined by POSIX. + expr += pattern[i:j].replace("\\", "\\\\") + + # Add regex bracket expression to regex result. + regex += expr + + # Set i to one past the closing bracket. + i = j + + else: + # Failed to find closing bracket, treat opening bracket as a + # bracket literal instead of as an expression. + regex += "\\[" + + else: + # Regular character, escape it for regex. + regex += re.escape(char) + + if escape: + raise ValueError(f"Escape character found with no next character to escape: {pattern!r}") + + return regex + + @staticmethod + def escape(s: AnyStr) -> AnyStr: + """Escape special characters in the given string. + + :param s: a filename or a string that you want to escape, usually before adding it to a ".gitignore". + :type s: AnyStr + :return: The escaped string + :rtype: Union[str, bytes] + """ + if isinstance(s, str): + return_type = str + string = s + elif isinstance(s, bytes): + return_type = bytes + string = s.decode(_BYTES_ENCODING) + else: + raise TypeError(f"s:{s!r} is not a unicode or byte string.") + + # Reference: https://git-scm.com/docs/gitignore#_pattern_format + meta_characters = r"[]!*#?" + + out_string = "".join("\\" + x if x in meta_characters else x for x in string) + + if return_type is bytes: + return out_string.encode(_BYTES_ENCODING) + return out_string + + +def normalize_file(file: Union[str, os.PathLike], separators: Optional[Iterable[str]] = None) -> str: + """Normalizes the file path to use the POSIX path separator (i.e., + ``'/'``), and make the paths relative (remove leading ``'/'``). + + :param file: The file path. + :type file: Union[str, os.PathLike] + :param separators: The path separators to normalize. This does not need to include the POSIX path separator + (``'/'``), but including it will not affect the results. Default is :data:`None` for + :data:`NORMALIZE_PATH_SEPS`. To prevent normalization, pass an empty container (e.g., an empty tuple ``()``). + :type separators: Optional[Iterable[str]] + :return: The normalized file path. + :rtype: str + """ + # Normalize path separators. + if separators is None: + separators = NORMALIZE_PATH_SEPS + + # Convert path object to string. + norm_file = str(file) + + for sep in separators: + norm_file = norm_file.replace(sep, posixpath.sep) + + if norm_file.startswith("/"): + # Make path relative. + norm_file = norm_file[1:] + + elif norm_file.startswith("./"): + # Remove current directory prefix. + norm_file = norm_file[2:] + + return norm_file diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_preflight_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_preflight_utils.py new file mode 100644 index 00000000..2a8e8053 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_preflight_utils.py @@ -0,0 +1,26 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import logging +from typing import Optional + +from azure.ai.ml._azure_environments import _get_base_url_from_metadata +from azure.ai.ml._vendor.azure_resources._resource_management_client import ResourceManagementClient +from azure.ai.ml._vendor.azure_resources.operations import DeploymentsOperations +from azure.ai.ml.constants._common import ArmConstants +from azure.core.credentials import TokenCredential + +module_logger = logging.getLogger(__name__) + + +def get_deployments_operation(credentials: TokenCredential, subscription_id: str) -> Optional[DeploymentsOperations]: + if subscription_id is None: + return None + client = ResourceManagementClient( + credential=credentials, + subscription_id=subscription_id, + base_url=_get_base_url_from_metadata(), + api_version=ArmConstants.AZURE_MGMT_RESOURCE_API_VERSION, + ) + return client.deployments diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_registry_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_registry_utils.py new file mode 100644 index 00000000..09c5d1ae --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_registry_utils.py @@ -0,0 +1,222 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import logging +from typing import Optional, Tuple + +from typing_extensions import Literal + +from azure.ai.ml._azure_environments import _get_default_cloud_name, _get_registry_discovery_endpoint_from_metadata +from azure.ai.ml._restclient.registry_discovery import AzureMachineLearningWorkspaces as ServiceClientRegistryDiscovery +from azure.ai.ml._restclient.v2021_10_01_dataplanepreview import AzureMachineLearningWorkspaces +from azure.ai.ml._restclient.v2021_10_01_dataplanepreview.models import ( + BlobReferenceSASRequestDto, + TemporaryDataReferenceRequestDto, +) +from azure.ai.ml.constants._common import REGISTRY_ASSET_ID +from azure.ai.ml.exceptions import MlException +from azure.core.exceptions import HttpResponseError + +module_logger = logging.getLogger(__name__) + +MFE_PATH_PREFIX = "mferp/managementfrontend" + + +class RegistryDiscovery: + def __init__( + self, + credential: str, + registry_name: str, + service_client_registry_discovery_client: ServiceClientRegistryDiscovery, + **kwargs, + ): + self.credential = credential + self.registry_name = registry_name + self.service_client_registry_discovery_client = service_client_registry_discovery_client + self.kwargs = kwargs + self._resource_group = None + self._subscription_id = None + self._base_url = None + self.workspace_region = kwargs.get("workspace_location", None) + + def _get_registry_details(self) -> str: + response = self.service_client_registry_discovery_client.registry_management_non_workspace.registry_management_non_workspace( # pylint: disable=line-too-long + self.registry_name + ) + if self.workspace_region: + _check_region_fqdn(self.workspace_region, response) + self._base_url = f"https://cert-{self.workspace_region}.experiments.azureml.net/{MFE_PATH_PREFIX}" + else: + self._base_url = f"{response.primary_region_resource_provider_uri}{MFE_PATH_PREFIX}" + self._subscription_id = response.subscription_id + self._resource_group = response.resource_group + + def get_registry_service_client(self) -> AzureMachineLearningWorkspaces: + self._get_registry_details() + self.kwargs.pop("subscription_id", None) + self.kwargs.pop("resource_group", None) + service_client_10_2021_dataplanepreview = AzureMachineLearningWorkspaces( + subscription_id=self._subscription_id, + resource_group=self._resource_group, + credential=self.credential, + base_url=self._base_url, + **self.kwargs, + ) + return service_client_10_2021_dataplanepreview + + @property + def subscription_id(self) -> str: + """The subscription id of the registry. + + :return: Subscription Id + :rtype: str + """ + return self._subscription_id + + @property + def resource_group(self) -> str: + """The resource group of the registry. + + :return: Resource Group + :rtype: str + """ + return self._resource_group + + +def get_sas_uri_for_registry_asset(service_client, name, version, resource_group, registry, body) -> str: + """Get sas_uri for registry asset. + + :param service_client: Service client + :type service_client: AzureMachineLearningWorkspaces + :param name: Asset name + :type name: str + :param version: Asset version + :type version: str + :param resource_group: Resource group + :type resource_group: str + :param registry: Registry name + :type registry: str + :param body: Request body + :type body: TemporaryDataReferenceRequestDto + :rtype: str + """ + sas_uri = None + try: + res = service_client.temporary_data_references.create_or_get_temporary_data_reference( + name=name, + version=version, + resource_group_name=resource_group, + registry_name=registry, + body=body, + ) + sas_uri = res.blob_reference_for_consumption.credential.additional_properties["sasUri"] + except HttpResponseError as e: + # "Asset already exists" exception is thrown from service with error code 409, that we need to ignore + if e.status_code == 409: + module_logger.debug("Skipping file upload, reason: %s", str(e.reason)) + else: + raise e + return sas_uri + + +def get_asset_body_for_registry_storage( + registry_name: str, asset_type: str, asset_name: str, asset_version: str +) -> TemporaryDataReferenceRequestDto: + """Get Asset body for registry. + + :param registry_name: Registry name. + :type registry_name: str + :param asset_type: Asset type. + :type asset_type: str + :param asset_name: Asset name. + :type asset_name: str + :param asset_version: Asset version. + :type asset_version: str + :return: The temporary data reference request dto + :rtype: TemporaryDataReferenceRequestDto + """ + body = TemporaryDataReferenceRequestDto( + asset_id=REGISTRY_ASSET_ID.format(registry_name, asset_type, asset_name, asset_version), + temporary_data_reference_type="TemporaryBlobReference", + ) + return body + + +def get_storage_details_for_registry_assets( + service_client: AzureMachineLearningWorkspaces, + asset_type: str, + asset_name: str, + asset_version: str, + rg_name: str, + reg_name: str, + uri: str, +) -> Tuple[str, Literal["NoCredentials", "SAS"]]: + """Get storage details for registry assets. + + :param service_client: AzureMachineLearningWorkspaces service client. + :type service_client: AzureMachineLearningWorkspaces + :param asset_type: Asset type. + :type asset_type: str + :param asset_name: Asset name. + :type asset_name: str + :param asset_version: Asset version. + :type asset_version: str + :param rg_name: Resource group name. + :type rg_name: str + :param reg_name: Registry name + :type reg_name: str + :param uri: asset uri + :type uri: str + :return: A 2-tuple of a URI and a string. Either: + * A blob uri and "NoCredentials" + * A sas URI and "SAS" + :rtype: Tuple[str, Literal["NoCredentials", "SAS"]] + """ + body = BlobReferenceSASRequestDto( + asset_id=REGISTRY_ASSET_ID.format(reg_name, asset_type, asset_name, asset_version), + blob_uri=uri, + ) + sas_uri = service_client.data_references.get_blob_reference_sas( + name=asset_name, + version=asset_version, + resource_group_name=rg_name, + registry_name=reg_name, + body=body, + ) + if sas_uri.blob_reference_for_consumption.credential.credential_type == "no_credentials": + return sas_uri.blob_reference_for_consumption.blob_uri, "NoCredentials" + + return ( + sas_uri.blob_reference_for_consumption.credential.additional_properties["sasUri"], + "SAS", + ) + + +def get_registry_client(credential, registry_name, workspace_location: Optional[str] = None, **kwargs): + base_url = _get_registry_discovery_endpoint_from_metadata(_get_default_cloud_name()) + kwargs.pop("base_url", None) + + service_client_registry_discovery_client = ServiceClientRegistryDiscovery( + credential=credential, base_url=base_url, **kwargs + ) + if workspace_location: + workspace_kwargs = {"workspace_location": workspace_location} + kwargs.update(workspace_kwargs) + + registry_discovery = RegistryDiscovery( + credential, registry_name, service_client_registry_discovery_client, **kwargs + ) + service_client_10_2021_dataplanepreview = registry_discovery.get_registry_service_client() + subscription_id = registry_discovery.subscription_id + resource_group_name = registry_discovery.resource_group + return service_client_10_2021_dataplanepreview, resource_group_name, subscription_id + + +def _check_region_fqdn(workspace_region, response): + if workspace_region in response.additional_properties["registryFqdns"].keys(): + return + regions = list(response.additional_properties["registryFqdns"].keys()) + msg = f"Workspace region {workspace_region} not supported by the \ + registry {response.registry_name} regions {regions}" + raise MlException(message=msg, no_personal_data_message=msg) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_storage_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_storage_utils.py new file mode 100644 index 00000000..df2ec65f --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_storage_utils.py @@ -0,0 +1,207 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import logging +import re +from typing import Optional, Tuple, Union + +from azure.ai.ml._artifacts._blob_storage_helper import BlobStorageClient +from azure.ai.ml._artifacts._constants import STORAGE_URI_REGEX +from azure.ai.ml._artifacts._fileshare_storage_helper import FileStorageClient +from azure.ai.ml._artifacts._gen2_storage_helper import Gen2StorageClient +from azure.ai.ml._azure_environments import _get_storage_endpoint_from_metadata +from azure.ai.ml._restclient.v2022_10_01.models import DatastoreType +from azure.ai.ml.constants._common import ( + FILE_PREFIX, + FOLDER_PREFIX, + JOB_URI_REGEX_FORMAT, + LONG_URI_FORMAT, + LONG_URI_REGEX_FORMAT, + MLFLOW_URI_REGEX_FORMAT, + OUTPUT_URI_REGEX_FORMAT, + SHORT_URI_FORMAT, + SHORT_URI_REGEX_FORMAT, + STORAGE_ACCOUNT_URLS, +) +from azure.ai.ml.exceptions import ErrorTarget, MlException, ValidationErrorType, ValidationException + +module_logger = logging.getLogger(__name__) + + +class AzureMLDatastorePathUri: + """Parser for an azureml:// datastore path URI, e.g.: azureml://datastores/mydatastore/paths/images/dogs'. + + :param uri: The AzureML datastore path URI. + :type uri: str + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the AzureML datastore + path URI is incorrectly formatted. + ' + """ + + def __init__(self, uri: str): + if uri.startswith(FILE_PREFIX): + uri = uri[len(FILE_PREFIX) :] + elif uri.startswith(FOLDER_PREFIX): + uri = uri[len(FOLDER_PREFIX) :] + self.uri = uri + + short_uri_match = re.match(SHORT_URI_REGEX_FORMAT, uri) + ml_flow_uri_match = re.match(MLFLOW_URI_REGEX_FORMAT, uri) + job_uri_match = re.match(JOB_URI_REGEX_FORMAT, uri) + long_uri_match = re.match(LONG_URI_REGEX_FORMAT, uri) + output_uri_match = re.match(OUTPUT_URI_REGEX_FORMAT, uri) + + if short_uri_match: + self.datastore = short_uri_match.group(1) + self.path = short_uri_match.group(2) + self.uri_type = "Datastore" + self.workspace_name = None + self.resource_group = None + self.subscription_id = None + elif ml_flow_uri_match: + self.datastore = ml_flow_uri_match.group(1) + self.path = ml_flow_uri_match.group(2) + self.uri_type = "MlFlow" + self.workspace_name = None + self.resource_group = None + self.subscription_id = None + elif job_uri_match: + self.datastore = job_uri_match.group(1) + self.path = job_uri_match.group(2) + self.uri_type = "Job" + self.workspace_name = None + self.resource_group = None + self.subscription_id = None + elif output_uri_match: + self.datastore = output_uri_match.group(1) + self.path = output_uri_match.group(2) + self.uri_type = None + self.workspace_name = None + self.resource_group = None + self.subscription_id = None + elif long_uri_match: + self.datastore = long_uri_match.group(4) + self.path = long_uri_match.group(5) + self.uri_type = "Datastore" + self.workspace_name = long_uri_match.group(3) + self.resource_group = long_uri_match.group(2) + self.subscription_id = long_uri_match.group(1) + else: + msg = "Invalid AzureML datastore path URI {}" + raise ValidationException( + message=msg.format(uri), + no_personal_data_message=msg.format("[uri]"), + target=ErrorTarget.DATASTORE, + error_type=ValidationErrorType.INVALID_VALUE, + ) + + def to_short_uri(self) -> str: + return SHORT_URI_FORMAT.format(self.datastore, self.path) + + def to_long_uri(self, subscription_id: str, resource_group_name: str, workspace_name: str) -> str: + return LONG_URI_FORMAT.format( + subscription_id, + resource_group_name, + workspace_name, + self.datastore, + self.path, + ) + + def get_uri_type(self) -> str: + if self.uri[0:20] == "azureml://datastores": + return "Datastore" + if self.uri[0:14] == "azureml://jobs": + return "Jobs" + + if self.uri[0 : self.uri.find(":")] == "runs": + return "MLFlow" + msg = "Invalid uri format for {}. URI must start with 'azureml://' or 'runs:/'" + raise ValidationException( + message=msg.format(self.uri), + no_personal_data_message=msg.format("[self.uri]"), + target=ErrorTarget.DATASTORE, + error_type=ValidationErrorType.INVALID_VALUE, + ) + + +def get_storage_client( + credential: str, + storage_account: str, + storage_type: Union[DatastoreType, str] = DatastoreType.AZURE_BLOB, + account_url: Optional[str] = None, + container_name: Optional[str] = None, +) -> Union[BlobStorageClient, FileStorageClient, Gen2StorageClient]: + """Return a storage client class instance based on the storage account type. + + :param credential: The credential + :type credential: str + :param storage_account: The storage_account name + :type storage_account: str + :param storage_type: The storage type + :type storage_type: Union[DatastoreType, str] + :param account_url: The account url + :type account_url: Optional[str] + :param container_name: The container name + :type container_name: Optional[str] + :return: The storage client + :rtype: Union[BlobStorageClient, FileStorageClient, Gen2StorageClient] + """ + client_builders = { + DatastoreType.AZURE_BLOB: lambda credential, container_name, account_url: BlobStorageClient( + credential=credential, account_url=account_url, container_name=container_name + ), + DatastoreType.AZURE_DATA_LAKE_GEN2: lambda credential, container_name, account_url: Gen2StorageClient( + credential=credential, file_system=container_name, account_url=account_url + ), + DatastoreType.AZURE_FILE: lambda credential, container_name, account_url: FileStorageClient( + credential=credential, file_share_name=container_name, account_url=account_url + ), + } + + if storage_type not in client_builders: + msg = ( + f"Datastore type {storage_type} is not supported. Supported storage" + + f"types for artifact upload include: {*client_builders,}" + ) + raise ValidationException( + message=msg, + no_personal_data_message=msg, + target=ErrorTarget.DATASTORE, + error_type=ValidationErrorType.INVALID_VALUE, + ) + + storage_endpoint = _get_storage_endpoint_from_metadata() + if not account_url and storage_endpoint: + account_url = STORAGE_ACCOUNT_URLS[storage_type].format(storage_account, storage_endpoint) + return client_builders[storage_type](credential, container_name, account_url) + + +def get_artifact_path_from_storage_url(blob_url: str, container_name: dict) -> str: + split_blob_url = blob_url.split(container_name) + if len(split_blob_url) > 1: + path = split_blob_url[-1] + if path.startswith("/"): + return path[1:] + return path + return blob_url + + +def get_ds_name_and_path_prefix(asset_uri: str, registry_name: Optional[str] = None) -> Tuple[str, str]: + if registry_name: + try: + split_paths = re.findall(STORAGE_URI_REGEX, asset_uri) + path_prefix = split_paths[0][-1] + except Exception as e: + msg = "Registry asset URI could not be parsed." + raise MlException(message=msg, no_personal_data_message=msg) from e + ds_name = None + else: + try: + ds_name = asset_uri.split("paths")[0].split("/")[-2] + path_prefix = asset_uri.split("paths")[1][1:] + except Exception as e: + msg = "Workspace asset URI could not be parsed." + raise MlException(message=msg, no_personal_data_message=msg) from e + + return ds_name, path_prefix diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/__init__.py new file mode 100644 index 00000000..dcf2df4f --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/__init__.py @@ -0,0 +1,57 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +from azure.ai.ml.entities import Job +from azure.ai.ml.entities._job.base_job import _BaseJob +from azure.ai.ml.entities._system_data import SystemData + +from ._restclient.index_service_apis import IndexServiceAPIs +from ._restclient.index_service_apis.models import ( + CrossRegionIndexEntitiesRequest, + IndexEntitiesRequest, + IndexEntitiesRequestFilter, + IndexEntitiesRequestOrder, + IndexEntitiesRequestOrderDirection, + IndexEntityResponse, +) + +__path__ = __import__("pkgutil").extend_path(__path__, __name__) # type: ignore + + +def index_entity_response_to_job(entity: IndexEntityResponse) -> Job: + properties = entity.properties + annotations = entity.annotations + creation_context = SystemData( + created_by=properties.creation_context.created_by.user_name, + created_by_type="User", + created_at=properties.creation_context.created_time, + ) + + return _BaseJob( + name=properties.additional_properties["runId"], + display_name=annotations.additional_properties["displayName"], + description=annotations.additional_properties["description"] or "", + tags=annotations.tags, + properties=properties.additional_properties["userProperties"], + experiment_name=properties.additional_properties["experimentName"], + services={}, + status=annotations.additional_properties["status"], + creation_context=creation_context, + compute=( + properties.additional_properties["compute"]["armId"] + if "compute" in properties.additional_properties + else None + ), + ) + + +__all__ = [ + "IndexServiceAPIs", + "CrossRegionIndexEntitiesRequest", + "IndexEntitiesRequest", + "IndexEntitiesRequestFilter", + "IndexEntitiesRequestOrder", + "IndexEntitiesRequestOrderDirection", + "index_entity_response_to_job", +] diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/__init__.py new file mode 100644 index 00000000..29a4fcd3 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/__init__.py @@ -0,0 +1,5 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +__path__ = __import__("pkgutil").extend_path(__path__, __name__) # type: ignore diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/__init__.py new file mode 100644 index 00000000..bbe9c82c --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/__init__.py @@ -0,0 +1,17 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from ._index_service_apis import IndexServiceAPIs +from ._version import VERSION + +__version__ = VERSION +__all__ = ["IndexServiceAPIs"] + +# `._patch.py` is used for handwritten extensions to the generated code +# Example: https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md +from ._patch import patch_sdk + +patch_sdk() diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_configuration.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_configuration.py new file mode 100644 index 00000000..abe36f8c --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_configuration.py @@ -0,0 +1,63 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from typing import TYPE_CHECKING + +from azure.core.configuration import Configuration +from azure.core.pipeline import policies +from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy + +from ._version import VERSION + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any + + from azure.core.credentials import TokenCredential + + +class IndexServiceAPIsConfiguration(Configuration): # pylint: disable=too-many-instance-attributes + """Configuration for IndexServiceAPIs. + + Note that all parameters used to create this instance are saved as instance + attributes. + + :param credential: Credential needed for the client to connect to Azure. + :type credential: ~azure.core.credentials.TokenCredential + """ + + def __init__( + self, + credential, # type: "TokenCredential" + **kwargs # type: Any + ): + # type: (...) -> None + super(IndexServiceAPIsConfiguration, self).__init__(**kwargs) + if credential is None: + raise ValueError("Parameter 'credential' must not be None.") + + self.credential = credential + self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "indexserviceapis/{}".format(VERSION)) + self._configure(**kwargs) + + def _configure( + self, **kwargs # type: Any + ): + # type: (...) -> None + self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) + self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") + if self.credential and not self.authentication_policy: + self.authentication_policy = ARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_index_service_apis.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_index_service_apis.py new file mode 100644 index 00000000..c0d3b3bf --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_index_service_apis.py @@ -0,0 +1,91 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from copy import deepcopy +from typing import TYPE_CHECKING + +from msrest import Deserializer, Serializer + +from azure.mgmt.core import ARMPipelineClient + +from . import models +from ._configuration import IndexServiceAPIsConfiguration +from .operations import IndexEntitiesOperations + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any + + from azure.core.credentials import TokenCredential + from azure.core.rest import HttpRequest, HttpResponse + + +class IndexServiceAPIs(object): + """IndexServiceAPIs. + + :ivar index_entities: IndexEntitiesOperations operations + :vartype index_entities: index_service_apis.operations.IndexEntitiesOperations + :param credential: Credential needed for the client to connect to Azure. + :type credential: ~azure.core.credentials.TokenCredential + :param base_url: Service URL. Default value is ''. + :type base_url: str + """ + + def __init__( + self, + credential, # type: "TokenCredential" + base_url="", # type: str + **kwargs # type: Any + ): + # type: (...) -> None + self._config = IndexServiceAPIsConfiguration(credential=credential, **kwargs) + self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs) + + client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} + self._serialize = Serializer(client_models) + self._deserialize = Deserializer(client_models) + self._serialize.client_side_validation = False + self.index_entities = IndexEntitiesOperations(self._client, self._config, self._serialize, self._deserialize) + + def _send_request( + self, + request, # type: HttpRequest + **kwargs # type: Any + ): + # type: (...) -> HttpResponse + """Runs the network request through the client's chained policies. + + >>> from azure.core.rest import HttpRequest + >>> request = HttpRequest("GET", "https://www.example.org/") + <HttpRequest [GET], url: 'https://www.example.org/'> + >>> response = client._send_request(request) + <HttpResponse: 200 OK> + + For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + + :param request: The network request you want to make. Required. + :type request: ~azure.core.rest.HttpRequest + :keyword bool stream: Whether the response payload will be streamed. Defaults to False. + :return: The response of your network call. Does not do error handling on your response. + :rtype: ~azure.core.rest.HttpResponse + """ + + request_copy = deepcopy(request) + request_copy.url = self._client.format_url(request_copy.url) + return self._client.send_request(request_copy, **kwargs) + + def close(self): + # type: () -> None + self._client.close() + + def __enter__(self): + # type: () -> IndexServiceAPIs + self._client.__enter__() + return self + + def __exit__(self, *exc_details): + # type: (Any) -> None + self._client.__exit__(*exc_details) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_patch.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_patch.py new file mode 100644 index 00000000..17dbc073 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_patch.py @@ -0,0 +1,32 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# +# Copyright (c) Microsoft Corporation. All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the ""Software""), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. +# +# -------------------------------------------------------------------------- + + +# This file is used for handwritten extensions to the generated code. Example: +# https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md +def patch_sdk(): + pass diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_vendor.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_vendor.py new file mode 100644 index 00000000..cc6e8179 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_vendor.py @@ -0,0 +1,14 @@ +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.core.pipeline.transport import HttpRequest + + +def _convert_request(request, files=None): + data = request.content if not files else None + request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) + if files: + request.set_formdata_body(files) + return request diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_version.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_version.py new file mode 100644 index 00000000..c45fe3b0 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/_version.py @@ -0,0 +1,7 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +VERSION = "0.1.0" diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/__init__.py new file mode 100644 index 00000000..a22bc3dd --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/__init__.py @@ -0,0 +1,15 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from ._index_service_apis import IndexServiceAPIs + +__all__ = ["IndexServiceAPIs"] + +# `._patch.py` is used for handwritten extensions to the generated code +# Example: https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md +from ._patch import patch_sdk + +patch_sdk() diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_configuration.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_configuration.py new file mode 100644 index 00000000..1476e175 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_configuration.py @@ -0,0 +1,53 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from typing import Any, TYPE_CHECKING + +from azure.core.configuration import Configuration +from azure.core.pipeline import policies +from azure.mgmt.core.policies import ARMHttpLoggingPolicy, AsyncARMChallengeAuthenticationPolicy + +from .._version import VERSION + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from azure.core.credentials_async import AsyncTokenCredential + + +class IndexServiceAPIsConfiguration(Configuration): # pylint: disable=too-many-instance-attributes + """Configuration for IndexServiceAPIs. + + Note that all parameters used to create this instance are saved as instance + attributes. + + :param credential: Credential needed for the client to connect to Azure. + :type credential: ~azure.core.credentials_async.AsyncTokenCredential + """ + + def __init__(self, credential: "AsyncTokenCredential", **kwargs: Any) -> None: + super(IndexServiceAPIsConfiguration, self).__init__(**kwargs) + if credential is None: + raise ValueError("Parameter 'credential' must not be None.") + + self.credential = credential + self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "indexserviceapis/{}".format(VERSION)) + self._configure(**kwargs) + + def _configure(self, **kwargs: Any) -> None: + self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs) + self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs) + self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs) + self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs) + self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") + if self.credential and not self.authentication_policy: + self.authentication_policy = AsyncARMChallengeAuthenticationPolicy( + self.credential, *self.credential_scopes, **kwargs + ) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_index_service_apis.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_index_service_apis.py new file mode 100644 index 00000000..33a8eca6 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_index_service_apis.py @@ -0,0 +1,75 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from copy import deepcopy +from typing import Any, Awaitable, TYPE_CHECKING + +from msrest import Deserializer, Serializer + +from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.mgmt.core import AsyncARMPipelineClient + +from .. import models +from ._configuration import IndexServiceAPIsConfiguration +from .operations import IndexEntitiesOperations + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from azure.core.credentials_async import AsyncTokenCredential + + +class IndexServiceAPIs: + """IndexServiceAPIs. + + :ivar index_entities: IndexEntitiesOperations operations + :vartype index_entities: index_service_apis.aio.operations.IndexEntitiesOperations + :param credential: Credential needed for the client to connect to Azure. + :type credential: ~azure.core.credentials_async.AsyncTokenCredential + :param base_url: Service URL. Default value is ''. + :type base_url: str + """ + + def __init__(self, credential: "AsyncTokenCredential", base_url: str = "", **kwargs: Any) -> None: + self._config = IndexServiceAPIsConfiguration(credential=credential, **kwargs) + self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs) + + client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} + self._serialize = Serializer(client_models) + self._deserialize = Deserializer(client_models) + self._serialize.client_side_validation = False + self.index_entities = IndexEntitiesOperations(self._client, self._config, self._serialize, self._deserialize) + + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: + """Runs the network request through the client's chained policies. + + >>> from azure.core.rest import HttpRequest + >>> request = HttpRequest("GET", "https://www.example.org/") + <HttpRequest [GET], url: 'https://www.example.org/'> + >>> response = await client._send_request(request) + <AsyncHttpResponse: 200 OK> + + For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + + :param request: The network request you want to make. Required. + :type request: ~azure.core.rest.HttpRequest + :keyword bool stream: Whether the response payload will be streamed. Defaults to False. + :return: The response of your network call. Does not do error handling on your response. + :rtype: ~azure.core.rest.AsyncHttpResponse + """ + + request_copy = deepcopy(request) + request_copy.url = self._client.format_url(request_copy.url) + return self._client.send_request(request_copy, **kwargs) + + async def close(self) -> None: + await self._client.close() + + async def __aenter__(self) -> "IndexServiceAPIs": + await self._client.__aenter__() + return self + + async def __aexit__(self, *exc_details) -> None: + await self._client.__aexit__(*exc_details) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_patch.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_patch.py new file mode 100644 index 00000000..17dbc073 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/_patch.py @@ -0,0 +1,32 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# +# Copyright (c) Microsoft Corporation. All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the ""Software""), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. +# +# -------------------------------------------------------------------------- + + +# This file is used for handwritten extensions to the generated code. Example: +# https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md +def patch_sdk(): + pass diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/__init__.py new file mode 100644 index 00000000..19ac2fed --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/__init__.py @@ -0,0 +1,11 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from ._index_entities_operations import IndexEntitiesOperations + +__all__ = [ + "IndexEntitiesOperations", +] diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/_index_entities_operations.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/_index_entities_operations.py new file mode 100644 index 00000000..b38a0dcb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/aio/operations/_index_entities_operations.py @@ -0,0 +1,128 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from typing import Any, AsyncIterable, Callable, Dict, Optional, TypeVar + +from azure.core.async_paging import AsyncItemPaged, AsyncList +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) +from azure.core.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.mgmt.core.exceptions import ARMErrorFormat + +from ... import models as _models +from ..._vendor import _convert_request +from ...operations._index_entities_operations import build_get_entites_cross_region_request + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] + + +class IndexEntitiesOperations: + """IndexEntitiesOperations async operations. + + You should not instantiate this class directly. Instead, you should create a Client instance that + instantiates it for you and attaches it as an attribute. + + :ivar models: Alias to model classes used in this operation group. + :type models: ~index_service_apis.models + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. + """ + + models = _models + + def __init__(self, client, config, serializer, deserializer) -> None: + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self._config = config + + @distributed_trace + def get_entites_cross_region( + self, body: Optional["_models.CrossRegionIndexEntitiesRequest"] = None, **kwargs: Any + ) -> AsyncIterable["_models.IndexEntitiesResponse"]: + """get_entites_cross_region. + + :param body: + :type body: ~index_service_apis.models.CrossRegionIndexEntitiesRequest + :keyword callable cls: A custom type or function that will be passed the direct response + :return: An iterator like instance of either IndexEntitiesResponse or the result of + cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~index_service_apis.models.IndexEntitiesResponse] + :raises: ~azure.core.exceptions.HttpResponseError + """ + content_type = kwargs.pop("content_type", "application/json-patch+json") # type: Optional[str] + + cls = kwargs.pop("cls", None) # type: ClsType["_models.IndexEntitiesResponse"] + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {})) + + def prepare_request(next_link=None): + if not next_link: + if body is not None: + _json = self._serialize.body(body, "CrossRegionIndexEntitiesRequest") + else: + _json = None + + request = build_get_entites_cross_region_request( + content_type=content_type, + json=_json, + template_url=self.get_entites_cross_region.metadata["url"], + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) + + else: + if body is not None: + _json = self._serialize.body(body, "CrossRegionIndexEntitiesRequest") + else: + _json = None + + request = build_get_entites_cross_region_request( + content_type=content_type, + json=_json, + template_url=next_link, + ) + 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("IndexEntitiesResponse", pipeline_response) + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) + return None, AsyncList(list_of_elem) + + async def get_next(next_link=None): + request = prepare_request(next_link) + + pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access + request, stream=False, **kwargs + ) + 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) + + get_entites_cross_region.metadata = {"url": "/ux/v1.0/entities/crossRegion"} # type: ignore diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/__init__.py new file mode 100644 index 00000000..7e5d9a66 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/__init__.py @@ -0,0 +1,517 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +try: + from ._models_py3 import BatchEndpointAnnotations + from ._models_py3 import BatchEndpointProperties + from ._models_py3 import BatchendpointsUnversionedEntitiesResponse + from ._models_py3 import BatchendpointsUnversionedEntity + from ._models_py3 import Compute + from ._models_py3 import ComputeRequest + from ._models_py3 import ContainerResourceRequirements + from ._models_py3 import ControlOutput + from ._models_py3 import CreatedBy + from ._models_py3 import CreatedBy1 + from ._models_py3 import CreationContext + from ._models_py3 import CronTrigger + from ._models_py3 import CrossRegionIndexEntitiesRequest + from ._models_py3 import CrossRegionIndexEntitiesResponse + from ._models_py3 import CudaAttribute + from ._models_py3 import DataStoreAnnotations + from ._models_py3 import DataStoreProperties + from ._models_py3 import DatasetAnnotations + from ._models_py3 import DatasetProperties + from ._models_py3 import DatasetReference + from ._models_py3 import DatasetsVersionedEntitiesResponse + from ._models_py3 import DatasetsVersionedEntity + from ._models_py3 import DatastoresUnversionedEntitiesResponse + from ._models_py3 import DatastoresUnversionedEntity + from ._models_py3 import DebugInfoResponse + from ._models_py3 import DefinitionAnnotations + from ._models_py3 import DefinitionProperties + from ._models_py3 import EndpointComputeTarget + from ._models_py3 import EnvironmentAttributes + from ._models_py3 import EnvironmentsVersionedEntitiesResponse + from ._models_py3 import EnvironmentsVersionedEntity + from ._models_py3 import ErrorAdditionalInfo + from ._models_py3 import ErrorResponse + from ._models_py3 import ExperimentStatus + from ._models_py3 import Feature + from ._models_py3 import FeatureEntityVersionAnnotations + from ._models_py3 import FeatureEntityVersionProperties + from ._models_py3 import FeatureSetVersionAnnotations + from ._models_py3 import FeatureSetVersionProperties + from ._models_py3 import FeatureSourceDto + from ._models_py3 import FeatureTransformationDto + from ._models_py3 import FeatureentitiesVersionedEntitiesResponse + from ._models_py3 import FeatureentitiesVersionedEntity + from ._models_py3 import FeaturesetSpecification + from ._models_py3 import FeaturesetsVersionedEntitiesResponse + from ._models_py3 import FeaturesetsVersionedEntity + from ._models_py3 import FeaturestoreentitiesVersionedEntitiesResponse + from ._models_py3 import FeaturestoreentitiesVersionedEntity + from ._models_py3 import FreeTextSearchColumn + from ._models_py3 import GenericTriggerAnnotations + from ._models_py3 import GenericTriggerProperties + from ._models_py3 import GenerictriggersUnversionedEntitiesResponse + from ._models_py3 import GenerictriggersUnversionedEntity + from ._models_py3 import HighlightOptions + from ._models_py3 import IndependentPipelineAnnotations + from ._models_py3 import IndependentPipelineProperties + from ._models_py3 import IndependentpipelinesUnversionedEntitiesResponse + from ._models_py3 import IndependentpipelinesUnversionedEntity + from ._models_py3 import IndexAnnotations + from ._models_py3 import IndexColumn + from ._models_py3 import IndexColumnDto + from ._models_py3 import IndexEntitiesLocalOperationRequest + from ._models_py3 import IndexEntitiesRequest + from ._models_py3 import IndexEntitiesRequestFilter + from ._models_py3 import IndexEntitiesRequestGroup + from ._models_py3 import IndexEntitiesRequestOrder + from ._models_py3 import IndexEntitiesResponse + from ._models_py3 import IndexEntityContainerMetadata + from ._models_py3 import IndexEntityResponse + from ._models_py3 import IndexProperties + from ._models_py3 import IndexResourceDiscoveryResponseItem + from ._models_py3 import IndexResourceDiscoveryResponseItemPaginatedResult + from ._models_py3 import IndexedErrorResponse + from ._models_py3 import InnerErrorResponse + from ._models_py3 import InputNameAndDataTypeIdsList + from ._models_py3 import InternalUxPresenceWarmUpRequest + from ._models_py3 import JobCost + from ._models_py3 import MaterializationComputeResource + from ._models_py3 import MaterializationSettings + from ._models_py3 import ModelAnnotations + from ._models_py3 import ModelProperties + from ._models_py3 import ModelsVersionedEntitiesResponse + from ._models_py3 import ModelsVersionedEntity + from ._models_py3 import ModuleAnnotations + from ._models_py3 import ModuleProperties + from ._models_py3 import ModulesVersionedEntitiesResponse + from ._models_py3 import ModulesVersionedEntity + from ._models_py3 import NotificationSetting + from ._models_py3 import OnlineEndpointAnnotations + from ._models_py3 import OnlineEndpointProperties + from ._models_py3 import OnlineendpointsUnversionedEntitiesResponse + from ._models_py3 import OnlineendpointsUnversionedEntity + from ._models_py3 import OutputNameAndDataTypeId + from ._models_py3 import PipelineAnnotations + from ._models_py3 import PipelineDraftAnnotations + from ._models_py3 import PipelineDraftProperties + from ._models_py3 import PipelineProperties + from ._models_py3 import PipelineRunAnnotations + from ._models_py3 import PipelineRunProperties + from ._models_py3 import PipelinedraftsUnversionedEntitiesResponse + from ._models_py3 import PipelinedraftsUnversionedEntity + from ._models_py3 import PipelinerunsUnversionedEntitiesResponse + from ._models_py3 import PipelinerunsUnversionedEntity + from ._models_py3 import PipelinesVersionedEntitiesResponse + from ._models_py3 import PipelinesVersionedEntity + from ._models_py3 import Purpose + from ._models_py3 import Recurrence + from ._models_py3 import RecurrenceSchedule + from ._models_py3 import RecurrenceTrigger + from ._models_py3 import Relationship + from ._models_py3 import ResourceDiscoveryContainerMetadata + from ._models_py3 import ResourceDiscoveryContainerMetadataPaginatedResult + from ._models_py3 import ResourceDiscoveryRequest + from ._models_py3 import ResourceInformation + from ._models_py3 import ResourceRegion + from ._models_py3 import RootError + from ._models_py3 import RunAnnotations + from ._models_py3 import RunIndexMetricSummaryJValue + from ._models_py3 import RunIndexMetricSummaryObject + from ._models_py3 import RunIndexResourceMetricSummary + from ._models_py3 import RunProperties + from ._models_py3 import RunTypeV2Index + from ._models_py3 import RunsUnversionedEntitiesResponse + from ._models_py3 import RunsUnversionedEntity + from ._models_py3 import SingleShardFanoutData + from ._models_py3 import StringContainsRequest + from ._models_py3 import StructuredInterfaceParameter + from ._models_py3 import TimeDeltaDto + from ._models_py3 import TimestampColumnDto + from ._models_py3 import UnqueriableResourcesScope + from ._models_py3 import Usage + from ._models_py3 import UserDto + from ._models_py3 import UxPresenceResource + from ._models_py3 import UxWarmUpRequest + from ._models_py3 import VersionedAttribute + from ._models_py3 import Webhook + from ._models_py3 import WorkspaceContextWarmUpRequest +except (SyntaxError, ImportError): + from ._models import BatchEndpointAnnotations # type: ignore + from ._models import BatchEndpointProperties # type: ignore + from ._models import BatchendpointsUnversionedEntitiesResponse # type: ignore + from ._models import BatchendpointsUnversionedEntity # type: ignore + from ._models import Compute # type: ignore + from ._models import ComputeRequest # type: ignore + from ._models import ContainerResourceRequirements # type: ignore + from ._models import ControlOutput # type: ignore + from ._models import CreatedBy # type: ignore + from ._models import CreatedBy1 # type: ignore + from ._models import CreationContext # type: ignore + from ._models import CronTrigger # type: ignore + from ._models import CrossRegionIndexEntitiesRequest # type: ignore + from ._models import CrossRegionIndexEntitiesResponse # type: ignore + from ._models import CudaAttribute # type: ignore + from ._models import DataStoreAnnotations # type: ignore + from ._models import DataStoreProperties # type: ignore + from ._models import DatasetAnnotations # type: ignore + from ._models import DatasetProperties # type: ignore + from ._models import DatasetReference # type: ignore + from ._models import DatasetsVersionedEntitiesResponse # type: ignore + from ._models import DatasetsVersionedEntity # type: ignore + from ._models import DatastoresUnversionedEntitiesResponse # type: ignore + from ._models import DatastoresUnversionedEntity # type: ignore + from ._models import DebugInfoResponse # type: ignore + from ._models import DefinitionAnnotations # type: ignore + from ._models import DefinitionProperties # type: ignore + from ._models import EndpointComputeTarget # type: ignore + from ._models import EnvironmentAttributes # type: ignore + from ._models import EnvironmentsVersionedEntitiesResponse # type: ignore + from ._models import EnvironmentsVersionedEntity # type: ignore + from ._models import ErrorAdditionalInfo # type: ignore + from ._models import ErrorResponse # type: ignore + from ._models import ExperimentStatus # type: ignore + from ._models import Feature # type: ignore + from ._models import FeatureEntityVersionAnnotations # type: ignore + from ._models import FeatureEntityVersionProperties # type: ignore + from ._models import FeatureSetVersionAnnotations # type: ignore + from ._models import FeatureSetVersionProperties # type: ignore + from ._models import FeatureSourceDto # type: ignore + from ._models import FeatureTransformationDto # type: ignore + from ._models import FeatureentitiesVersionedEntitiesResponse # type: ignore + from ._models import FeatureentitiesVersionedEntity # type: ignore + from ._models import FeaturesetSpecification # type: ignore + from ._models import FeaturesetsVersionedEntitiesResponse # type: ignore + from ._models import FeaturesetsVersionedEntity # type: ignore + from ._models import FeaturestoreentitiesVersionedEntitiesResponse # type: ignore + from ._models import FeaturestoreentitiesVersionedEntity # type: ignore + from ._models import FreeTextSearchColumn # type: ignore + from ._models import GenericTriggerAnnotations # type: ignore + from ._models import GenericTriggerProperties # type: ignore + from ._models import GenerictriggersUnversionedEntitiesResponse # type: ignore + from ._models import GenerictriggersUnversionedEntity # type: ignore + from ._models import HighlightOptions # type: ignore + from ._models import IndependentPipelineAnnotations # type: ignore + from ._models import IndependentPipelineProperties # type: ignore + from ._models import IndependentpipelinesUnversionedEntitiesResponse # type: ignore + from ._models import IndependentpipelinesUnversionedEntity # type: ignore + from ._models import IndexAnnotations # type: ignore + from ._models import IndexColumn # type: ignore + from ._models import IndexColumnDto # type: ignore + from ._models import IndexEntitiesLocalOperationRequest # type: ignore + from ._models import IndexEntitiesRequest # type: ignore + from ._models import IndexEntitiesRequestFilter # type: ignore + from ._models import IndexEntitiesRequestGroup # type: ignore + from ._models import IndexEntitiesRequestOrder # type: ignore + from ._models import IndexEntitiesResponse # type: ignore + from ._models import IndexEntityContainerMetadata # type: ignore + from ._models import IndexEntityResponse # type: ignore + from ._models import IndexProperties # type: ignore + from ._models import IndexResourceDiscoveryResponseItem # type: ignore + from ._models import IndexResourceDiscoveryResponseItemPaginatedResult # type: ignore + from ._models import IndexedErrorResponse # type: ignore + from ._models import InnerErrorResponse # type: ignore + from ._models import InputNameAndDataTypeIdsList # type: ignore + from ._models import InternalUxPresenceWarmUpRequest # type: ignore + from ._models import JobCost # type: ignore + from ._models import MaterializationComputeResource # type: ignore + from ._models import MaterializationSettings # type: ignore + from ._models import ModelAnnotations # type: ignore + from ._models import ModelProperties # type: ignore + from ._models import ModelsVersionedEntitiesResponse # type: ignore + from ._models import ModelsVersionedEntity # type: ignore + from ._models import ModuleAnnotations # type: ignore + from ._models import ModuleProperties # type: ignore + from ._models import ModulesVersionedEntitiesResponse # type: ignore + from ._models import ModulesVersionedEntity # type: ignore + from ._models import NotificationSetting # type: ignore + from ._models import OnlineEndpointAnnotations # type: ignore + from ._models import OnlineEndpointProperties # type: ignore + from ._models import OnlineendpointsUnversionedEntitiesResponse # type: ignore + from ._models import OnlineendpointsUnversionedEntity # type: ignore + from ._models import OutputNameAndDataTypeId # type: ignore + from ._models import PipelineAnnotations # type: ignore + from ._models import PipelineDraftAnnotations # type: ignore + from ._models import PipelineDraftProperties # type: ignore + from ._models import PipelineProperties # type: ignore + from ._models import PipelineRunAnnotations # type: ignore + from ._models import PipelineRunProperties # type: ignore + from ._models import PipelinedraftsUnversionedEntitiesResponse # type: ignore + from ._models import PipelinedraftsUnversionedEntity # type: ignore + from ._models import PipelinerunsUnversionedEntitiesResponse # type: ignore + from ._models import PipelinerunsUnversionedEntity # type: ignore + from ._models import PipelinesVersionedEntitiesResponse # type: ignore + from ._models import PipelinesVersionedEntity # type: ignore + from ._models import Purpose # type: ignore + from ._models import Recurrence # type: ignore + from ._models import RecurrenceSchedule # type: ignore + from ._models import RecurrenceTrigger # type: ignore + from ._models import Relationship # type: ignore + from ._models import ResourceDiscoveryContainerMetadata # type: ignore + from ._models import ResourceDiscoveryContainerMetadataPaginatedResult # type: ignore + from ._models import ResourceDiscoveryRequest # type: ignore + from ._models import ResourceInformation # type: ignore + from ._models import ResourceRegion # type: ignore + from ._models import RootError # type: ignore + from ._models import RunAnnotations # type: ignore + from ._models import RunIndexMetricSummaryJValue # type: ignore + from ._models import RunIndexMetricSummaryObject # type: ignore + from ._models import RunIndexResourceMetricSummary # type: ignore + from ._models import RunProperties # type: ignore + from ._models import RunTypeV2Index # type: ignore + from ._models import RunsUnversionedEntitiesResponse # type: ignore + from ._models import RunsUnversionedEntity # type: ignore + from ._models import SingleShardFanoutData # type: ignore + from ._models import StringContainsRequest # type: ignore + from ._models import StructuredInterfaceParameter # type: ignore + from ._models import TimeDeltaDto # type: ignore + from ._models import TimestampColumnDto # type: ignore + from ._models import UnqueriableResourcesScope # type: ignore + from ._models import Usage # type: ignore + from ._models import UserDto # type: ignore + from ._models import UxPresenceResource # type: ignore + from ._models import UxWarmUpRequest # type: ignore + from ._models import VersionedAttribute # type: ignore + from ._models import Webhook # type: ignore + from ._models import WorkspaceContextWarmUpRequest # type: ignore + +from ._index_service_apis_enums import ( + AssetContainerTypeFeedRename, + BatchendpointsUnversionedEntityKind, + DataStoreAnnotationsDataStoreType, + DatasetsVersionedEntityKind, + DatastoresUnversionedEntityKind, + EntityKind, + EnvironmentsVersionedEntityKind, + ExperimentStatusCode, + FeatureDataType, + FeatureSourceDtoType, + FeatureentitiesVersionedEntityKind, + FeaturesetsVersionedEntityKind, + FeaturestoreentitiesVersionedEntityKind, + GenericTriggerAnnotationsEntityStatus, + GenericTriggerAnnotationsManagedType, + GenericTriggerAnnotationsProvisioningStatus, + GenericTriggerAnnotationsScheduleActionType, + GenericTriggerAnnotationsScheduleMethod, + GenericTriggerAnnotationsTriggerType, + GenerictriggersUnversionedEntityKind, + IndependentPipelineAnnotationsEntityStatus, + IndependentPipelineAnnotationsLastRunStatusCode, + IndependentpipelinesUnversionedEntityKind, + IndexColumnDataType, + IndexColumnDtoType, + IndexEntitiesRequestOrderDirection, + MaterializationSettingsMaterializationStoreType, + ModelsVersionedEntityKind, + ModuleAnnotationsAmlModuleEntityStatus, + ModuleAnnotationsEntityStatus, + ModuleAnnotationsModuleType, + ModulesVersionedEntityKind, + NotificationSettingEmailOnItem, + OnlineendpointsUnversionedEntityKind, + PipelineAnnotationsEntityStatus, + PipelineAnnotationsLastRunStatusCode, + PipelineDraftAnnotationsEntityStatus, + PipelineRunAnnotationsEntityStatus, + PipelinedraftsUnversionedEntityKind, + PipelinerunsUnversionedEntityKind, + PipelinesVersionedEntityKind, + RecurrenceFrequency, + RecurrenceScheduleWeekDaysItem, + RecurrenceTriggerFrequency, + RunsUnversionedEntityKind, + StructuredInterfaceParameterType, +) + +__all__ = [ + "BatchEndpointAnnotations", + "BatchEndpointProperties", + "BatchendpointsUnversionedEntitiesResponse", + "BatchendpointsUnversionedEntity", + "Compute", + "ComputeRequest", + "ContainerResourceRequirements", + "ControlOutput", + "CreatedBy", + "CreatedBy1", + "CreationContext", + "CronTrigger", + "CrossRegionIndexEntitiesRequest", + "CrossRegionIndexEntitiesResponse", + "CudaAttribute", + "DataStoreAnnotations", + "DataStoreProperties", + "DatasetAnnotations", + "DatasetProperties", + "DatasetReference", + "DatasetsVersionedEntitiesResponse", + "DatasetsVersionedEntity", + "DatastoresUnversionedEntitiesResponse", + "DatastoresUnversionedEntity", + "DebugInfoResponse", + "DefinitionAnnotations", + "DefinitionProperties", + "EndpointComputeTarget", + "EnvironmentAttributes", + "EnvironmentsVersionedEntitiesResponse", + "EnvironmentsVersionedEntity", + "ErrorAdditionalInfo", + "ErrorResponse", + "ExperimentStatus", + "Feature", + "FeatureEntityVersionAnnotations", + "FeatureEntityVersionProperties", + "FeatureSetVersionAnnotations", + "FeatureSetVersionProperties", + "FeatureSourceDto", + "FeatureTransformationDto", + "FeatureentitiesVersionedEntitiesResponse", + "FeatureentitiesVersionedEntity", + "FeaturesetSpecification", + "FeaturesetsVersionedEntitiesResponse", + "FeaturesetsVersionedEntity", + "FeaturestoreentitiesVersionedEntitiesResponse", + "FeaturestoreentitiesVersionedEntity", + "FreeTextSearchColumn", + "GenericTriggerAnnotations", + "GenericTriggerProperties", + "GenerictriggersUnversionedEntitiesResponse", + "GenerictriggersUnversionedEntity", + "HighlightOptions", + "IndependentPipelineAnnotations", + "IndependentPipelineProperties", + "IndependentpipelinesUnversionedEntitiesResponse", + "IndependentpipelinesUnversionedEntity", + "IndexAnnotations", + "IndexColumn", + "IndexColumnDto", + "IndexEntitiesLocalOperationRequest", + "IndexEntitiesRequest", + "IndexEntitiesRequestFilter", + "IndexEntitiesRequestGroup", + "IndexEntitiesRequestOrder", + "IndexEntitiesResponse", + "IndexEntityContainerMetadata", + "IndexEntityResponse", + "IndexProperties", + "IndexResourceDiscoveryResponseItem", + "IndexResourceDiscoveryResponseItemPaginatedResult", + "IndexedErrorResponse", + "InnerErrorResponse", + "InputNameAndDataTypeIdsList", + "InternalUxPresenceWarmUpRequest", + "JobCost", + "MaterializationComputeResource", + "MaterializationSettings", + "ModelAnnotations", + "ModelProperties", + "ModelsVersionedEntitiesResponse", + "ModelsVersionedEntity", + "ModuleAnnotations", + "ModuleProperties", + "ModulesVersionedEntitiesResponse", + "ModulesVersionedEntity", + "NotificationSetting", + "OnlineEndpointAnnotations", + "OnlineEndpointProperties", + "OnlineendpointsUnversionedEntitiesResponse", + "OnlineendpointsUnversionedEntity", + "OutputNameAndDataTypeId", + "PipelineAnnotations", + "PipelineDraftAnnotations", + "PipelineDraftProperties", + "PipelineProperties", + "PipelineRunAnnotations", + "PipelineRunProperties", + "PipelinedraftsUnversionedEntitiesResponse", + "PipelinedraftsUnversionedEntity", + "PipelinerunsUnversionedEntitiesResponse", + "PipelinerunsUnversionedEntity", + "PipelinesVersionedEntitiesResponse", + "PipelinesVersionedEntity", + "Purpose", + "Recurrence", + "RecurrenceSchedule", + "RecurrenceTrigger", + "Relationship", + "ResourceDiscoveryContainerMetadata", + "ResourceDiscoveryContainerMetadataPaginatedResult", + "ResourceDiscoveryRequest", + "ResourceInformation", + "ResourceRegion", + "RootError", + "RunAnnotations", + "RunIndexMetricSummaryJValue", + "RunIndexMetricSummaryObject", + "RunIndexResourceMetricSummary", + "RunProperties", + "RunTypeV2Index", + "RunsUnversionedEntitiesResponse", + "RunsUnversionedEntity", + "SingleShardFanoutData", + "StringContainsRequest", + "StructuredInterfaceParameter", + "TimeDeltaDto", + "TimestampColumnDto", + "UnqueriableResourcesScope", + "Usage", + "UserDto", + "UxPresenceResource", + "UxWarmUpRequest", + "VersionedAttribute", + "Webhook", + "WorkspaceContextWarmUpRequest", + "AssetContainerTypeFeedRename", + "BatchendpointsUnversionedEntityKind", + "DataStoreAnnotationsDataStoreType", + "DatasetsVersionedEntityKind", + "DatastoresUnversionedEntityKind", + "EntityKind", + "EnvironmentsVersionedEntityKind", + "ExperimentStatusCode", + "FeatureDataType", + "FeatureSourceDtoType", + "FeatureentitiesVersionedEntityKind", + "FeaturesetsVersionedEntityKind", + "FeaturestoreentitiesVersionedEntityKind", + "GenericTriggerAnnotationsEntityStatus", + "GenericTriggerAnnotationsManagedType", + "GenericTriggerAnnotationsProvisioningStatus", + "GenericTriggerAnnotationsScheduleActionType", + "GenericTriggerAnnotationsScheduleMethod", + "GenericTriggerAnnotationsTriggerType", + "GenerictriggersUnversionedEntityKind", + "IndependentPipelineAnnotationsEntityStatus", + "IndependentPipelineAnnotationsLastRunStatusCode", + "IndependentpipelinesUnversionedEntityKind", + "IndexColumnDataType", + "IndexColumnDtoType", + "IndexEntitiesRequestOrderDirection", + "MaterializationSettingsMaterializationStoreType", + "ModelsVersionedEntityKind", + "ModuleAnnotationsAmlModuleEntityStatus", + "ModuleAnnotationsEntityStatus", + "ModuleAnnotationsModuleType", + "ModulesVersionedEntityKind", + "NotificationSettingEmailOnItem", + "OnlineendpointsUnversionedEntityKind", + "PipelineAnnotationsEntityStatus", + "PipelineAnnotationsLastRunStatusCode", + "PipelineDraftAnnotationsEntityStatus", + "PipelineRunAnnotationsEntityStatus", + "PipelinedraftsUnversionedEntityKind", + "PipelinerunsUnversionedEntityKind", + "PipelinesVersionedEntityKind", + "RecurrenceFrequency", + "RecurrenceScheduleWeekDaysItem", + "RecurrenceTriggerFrequency", + "RunsUnversionedEntityKind", + "StructuredInterfaceParameterType", +] diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_index_service_apis_enums.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_index_service_apis_enums.py new file mode 100644 index 00000000..797089bb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_index_service_apis_enums.py @@ -0,0 +1,344 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta + + +class AssetContainerTypeFeedRename(str, Enum, metaclass=CaseInsensitiveEnumMeta): + WORKSPACE = "Workspace" + FEED = "Feed" + REGISTRY = "Registry" + + +class BatchendpointsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class DatasetsVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class DataStoreAnnotationsDataStoreType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AZURE_BLOB = "AzureBlob" + AZURE_FILE = "AzureFile" + GLUSTER_FS = "GlusterFs" + AZURE_DATA_LAKE = "AzureDataLake" + AZURE_MY_SQL = "AzureMySql" + CUSTOM = "Custom" + HDFS = "Hdfs" + AZURE_SQL_DATABASE = "AzureSqlDatabase" + AZURE_POSTGRE_SQL = "AzurePostgreSql" + DBFS = "DBFS" + AZURE_DATA_LAKE_GEN2 = "AzureDataLakeGen2" + + +class DatastoresUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class EntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class EnvironmentsVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class ExperimentStatusCode(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NOT_STARTED = "NotStarted" + RUNNING = "Running" + FAILED = "Failed" + FINISHED = "Finished" + CANCELED = "Canceled" + FAILING = "Failing" + + +class FeatureDataType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + STRING = "String" + INTEGER = "Integer" + LONG = "Long" + FLOAT = "Float" + DOUBLE = "Double" + BINARY = "Binary" + DATETIME = "Datetime" + BOOLEAN = "Boolean" + + +class FeatureentitiesVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class FeaturesetsVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class FeatureSourceDtoType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + MLTABLE = "mltable" + CSV = "csv" + PARQUET = "parquet" + + +class FeaturestoreentitiesVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class GenericTriggerAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACTIVE = "Active" + DEPRECATED = "Deprecated" + DISABLED = "Disabled" + + +class GenericTriggerAnnotationsManagedType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CUSTOMER = "Customer" + SYSTEM = "System" + + +class GenericTriggerAnnotationsProvisioningStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + COMPLETED = "Completed" + PROVISIONING = "Provisioning" + FAILED = "Failed" + + +class GenericTriggerAnnotationsScheduleActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CREATE_JOB = "CreateJob" + INVOKE_ENDPOINT = "InvokeEndpoint" + IMPORT_DATA = "ImportData" + MODEL_MONITOR = "ModelMonitor" + + +class GenericTriggerAnnotationsScheduleMethod(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CRON = "Cron" + RECURRENCE = "Recurrence" + + +class GenericTriggerAnnotationsTriggerType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + SCHEDULE = "Schedule" + ONCE = "Once" + + +class GenerictriggersUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class IndependentPipelineAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACTIVE = "Active" + DEPRECATED = "Deprecated" + DISABLED = "Disabled" + + +class IndependentPipelineAnnotationsLastRunStatusCode(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NOT_STARTED = "NotStarted" + RUNNING = "Running" + FAILED = "Failed" + FINISHED = "Finished" + CANCELED = "Canceled" + FAILING = "Failing" + QUEUED = "Queued" + CANCEL_REQUESTED = "CancelRequested" + + +class IndependentpipelinesUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class IndexColumnDataType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + STRING = "String" + INTEGER = "Integer" + LONG = "Long" + FLOAT = "Float" + DOUBLE = "Double" + BINARY = "Binary" + DATETIME = "Datetime" + BOOLEAN = "Boolean" + + +class IndexColumnDtoType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + STRING = "string" + INTEGER = "integer" + LONG = "long" + FLOAT = "float" + DOUBLE = "double" + BINARY = "binary" + DATETIME = "datetime" + BOOLEAN = "boolean" + + +class IndexEntitiesRequestOrderDirection(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ASC = "Asc" + DESC = "Desc" + + +class MaterializationSettingsMaterializationStoreType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NONE = "None" + ONLINE = "Online" + OFFLINE = "Offline" + ONLINE_AND_OFFLINE = "OnlineAndOffline" + + +class ModelsVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class ModuleAnnotationsAmlModuleEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACTIVE = "Active" + DEPRECATED = "Deprecated" + DISABLED = "Disabled" + + +class ModuleAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACTIVE = "Active" + DEPRECATED = "Deprecated" + DISABLED = "Disabled" + + +class ModuleAnnotationsModuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + USER = "User" + BUILTIN = "Builtin" + + +class ModulesVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class NotificationSettingEmailOnItem(str, Enum, metaclass=CaseInsensitiveEnumMeta): + JOB_COMPLETED = "JobCompleted" + JOB_FAILED = "JobFailed" + JOB_CANCELLED = "JobCancelled" + + +class OnlineendpointsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class PipelineAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACTIVE = "Active" + DEPRECATED = "Deprecated" + DISABLED = "Disabled" + + +class PipelineAnnotationsLastRunStatusCode(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NOT_STARTED = "NotStarted" + RUNNING = "Running" + FAILED = "Failed" + FINISHED = "Finished" + CANCELED = "Canceled" + FAILING = "Failing" + QUEUED = "Queued" + CANCEL_REQUESTED = "CancelRequested" + + +class PipelineDraftAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACTIVE = "Active" + DEPRECATED = "Deprecated" + DISABLED = "Disabled" + + +class PipelinedraftsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class PipelineRunAnnotationsEntityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACTIVE = "Active" + DEPRECATED = "Deprecated" + DISABLED = "Disabled" + + +class PipelinerunsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class PipelinesVersionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class RecurrenceFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta): + MONTH = "Month" + WEEK = "Week" + DAY = "Day" + HOUR = "Hour" + MINUTE = "Minute" + + +class RecurrenceScheduleWeekDaysItem(str, Enum, metaclass=CaseInsensitiveEnumMeta): + MONDAY = "Monday" + TUESDAY = "Tuesday" + WEDNESDAY = "Wednesday" + THURSDAY = "Thursday" + FRIDAY = "Friday" + SATURDAY = "Saturday" + SUNDAY = "Sunday" + + +class RecurrenceTriggerFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta): + MONTH = "Month" + WEEK = "Week" + DAY = "Day" + HOUR = "Hour" + MINUTE = "Minute" + + +class RunsUnversionedEntityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INVALID = "Invalid" + LINEAGE_ROOT = "LineageRoot" + VERSIONED = "Versioned" + UNVERSIONED = "Unversioned" + + +class StructuredInterfaceParameterType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INT = "Int" + DOUBLE = "Double" + BOOL = "Bool" + STRING = "String" + UNDEFINED = "Undefined" diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models.py new file mode 100644 index 00000000..2ff74b26 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models.py @@ -0,0 +1,9226 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +import msrest.serialization + + +class BatchEndpointAnnotations(msrest.serialization.Model): + """BatchEndpointAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar scoring_uri: Required. + :vartype scoring_uri: str + :ivar location: Required. + :vartype location: str + :ivar last_modified_time: Required. + :vartype last_modified_time: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "scoring_uri": {"required": True}, + "location": {"required": True}, + "last_modified_time": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "scoring_uri": {"key": "scoringUri", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword scoring_uri: Required. + :paramtype scoring_uri: str + :keyword location: Required. + :paramtype location: str + :keyword last_modified_time: Required. + :paramtype last_modified_time: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(BatchEndpointAnnotations, self).__init__(**kwargs) + self.scoring_uri = kwargs["scoring_uri"] + self.location = kwargs["location"] + self.last_modified_time = kwargs["last_modified_time"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class BatchEndpointProperties(msrest.serialization.Model): + """BatchEndpointProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "properties": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "properties": {"key": "properties", "type": "{str}"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(BatchEndpointProperties, self).__init__(**kwargs) + self.properties = kwargs["properties"] + self.creation_context = kwargs["creation_context"] + + +class BatchendpointsUnversionedEntitiesResponse(msrest.serialization.Model): + """BatchendpointsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.BatchendpointsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[BatchendpointsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.BatchendpointsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(BatchendpointsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class BatchendpointsUnversionedEntity(msrest.serialization.Model): + """BatchendpointsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.BatchendpointsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.BatchEndpointAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.BatchEndpointProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "BatchEndpointAnnotations"}, + "properties": {"key": "properties", "type": "BatchEndpointProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.BatchendpointsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.BatchEndpointAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.BatchEndpointProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(BatchendpointsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class Compute(msrest.serialization.Model): + """Compute. + + All required parameters must be populated in order to send to Azure. + + :ivar target: Required. + :vartype target: str + :ivar target_type: Required. + :vartype target_type: str + :ivar vm_size: Required. + :vartype vm_size: str + :ivar instance_type: Required. + :vartype instance_type: str + :ivar instance_count: Required. + :vartype instance_count: int + :ivar gpu_count: Required. + :vartype gpu_count: int + :ivar priority: Required. + :vartype priority: str + :ivar region: Required. + :vartype region: str + :ivar arm_id: Required. + :vartype arm_id: str + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + """ + + _validation = { + "target": {"required": True}, + "target_type": {"required": True}, + "vm_size": {"required": True}, + "instance_type": {"required": True}, + "instance_count": {"required": True}, + "gpu_count": {"required": True}, + "priority": {"required": True}, + "region": {"required": True}, + "arm_id": {"required": True}, + "properties": {"required": True}, + } + + _attribute_map = { + "target": {"key": "target", "type": "str"}, + "target_type": {"key": "targetType", "type": "str"}, + "vm_size": {"key": "vmSize", "type": "str"}, + "instance_type": {"key": "instanceType", "type": "str"}, + "instance_count": {"key": "instanceCount", "type": "int"}, + "gpu_count": {"key": "gpuCount", "type": "int"}, + "priority": {"key": "priority", "type": "str"}, + "region": {"key": "region", "type": "str"}, + "arm_id": {"key": "armId", "type": "str"}, + "properties": {"key": "properties", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword target: Required. + :paramtype target: str + :keyword target_type: Required. + :paramtype target_type: str + :keyword vm_size: Required. + :paramtype vm_size: str + :keyword instance_type: Required. + :paramtype instance_type: str + :keyword instance_count: Required. + :paramtype instance_count: int + :keyword gpu_count: Required. + :paramtype gpu_count: int + :keyword priority: Required. + :paramtype priority: str + :keyword region: Required. + :paramtype region: str + :keyword arm_id: Required. + :paramtype arm_id: str + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + """ + super(Compute, self).__init__(**kwargs) + self.target = kwargs["target"] + self.target_type = kwargs["target_type"] + self.vm_size = kwargs["vm_size"] + self.instance_type = kwargs["instance_type"] + self.instance_count = kwargs["instance_count"] + self.gpu_count = kwargs["gpu_count"] + self.priority = kwargs["priority"] + self.region = kwargs["region"] + self.arm_id = kwargs["arm_id"] + self.properties = kwargs["properties"] + + +class ComputeRequest(msrest.serialization.Model): + """ComputeRequest. + + All required parameters must be populated in order to send to Azure. + + :ivar node_count: Required. + :vartype node_count: int + :ivar gpu_count: Required. + :vartype gpu_count: int + """ + + _validation = { + "node_count": {"required": True}, + "gpu_count": {"required": True}, + } + + _attribute_map = { + "node_count": {"key": "nodeCount", "type": "int"}, + "gpu_count": {"key": "gpuCount", "type": "int"}, + } + + def __init__(self, **kwargs): + """ + :keyword node_count: Required. + :paramtype node_count: int + :keyword gpu_count: Required. + :paramtype gpu_count: int + """ + super(ComputeRequest, self).__init__(**kwargs) + self.node_count = kwargs["node_count"] + self.gpu_count = kwargs["gpu_count"] + + +class ContainerResourceRequirements(msrest.serialization.Model): + """ContainerResourceRequirements. + + All required parameters must be populated in order to send to Azure. + + :ivar cpu: Required. + :vartype cpu: float + :ivar cpu_limit: Required. + :vartype cpu_limit: float + :ivar memory_in_gb: Required. + :vartype memory_in_gb: float + :ivar memory_in_gb_limit: Required. + :vartype memory_in_gb_limit: float + :ivar gpu_enabled: Required. + :vartype gpu_enabled: bool + :ivar gpu: Required. + :vartype gpu: int + :ivar fpga: Required. + :vartype fpga: int + """ + + _validation = { + "cpu": {"required": True}, + "cpu_limit": {"required": True}, + "memory_in_gb": {"required": True}, + "memory_in_gb_limit": {"required": True}, + "gpu_enabled": {"required": True}, + "gpu": {"required": True}, + "fpga": {"required": True}, + } + + _attribute_map = { + "cpu": {"key": "cpu", "type": "float"}, + "cpu_limit": {"key": "cpuLimit", "type": "float"}, + "memory_in_gb": {"key": "memoryInGB", "type": "float"}, + "memory_in_gb_limit": {"key": "memoryInGBLimit", "type": "float"}, + "gpu_enabled": {"key": "gpuEnabled", "type": "bool"}, + "gpu": {"key": "gpu", "type": "int"}, + "fpga": {"key": "fpga", "type": "int"}, + } + + def __init__(self, **kwargs): + """ + :keyword cpu: Required. + :paramtype cpu: float + :keyword cpu_limit: Required. + :paramtype cpu_limit: float + :keyword memory_in_gb: Required. + :paramtype memory_in_gb: float + :keyword memory_in_gb_limit: Required. + :paramtype memory_in_gb_limit: float + :keyword gpu_enabled: Required. + :paramtype gpu_enabled: bool + :keyword gpu: Required. + :paramtype gpu: int + :keyword fpga: Required. + :paramtype fpga: int + """ + super(ContainerResourceRequirements, self).__init__(**kwargs) + self.cpu = kwargs["cpu"] + self.cpu_limit = kwargs["cpu_limit"] + self.memory_in_gb = kwargs["memory_in_gb"] + self.memory_in_gb_limit = kwargs["memory_in_gb_limit"] + self.gpu_enabled = kwargs["gpu_enabled"] + self.gpu = kwargs["gpu"] + self.fpga = kwargs["fpga"] + + +class ControlOutput(msrest.serialization.Model): + """ControlOutput. + + :ivar name: + :vartype name: str + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: + :paramtype name: str + """ + super(ControlOutput, self).__init__(**kwargs) + self.name = kwargs.get("name", None) + + +class CreatedBy(msrest.serialization.Model): + """CreatedBy. + + :ivar user_object_id: + :vartype user_object_id: str + :ivar user_tenant_id: + :vartype user_tenant_id: str + :ivar user_name: + :vartype user_name: str + """ + + _attribute_map = { + "user_object_id": {"key": "userObjectId", "type": "str"}, + "user_tenant_id": {"key": "userTenantId", "type": "str"}, + "user_name": {"key": "userName", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword user_object_id: + :paramtype user_object_id: str + :keyword user_tenant_id: + :paramtype user_tenant_id: str + :keyword user_name: + :paramtype user_name: str + """ + super(CreatedBy, self).__init__(**kwargs) + self.user_object_id = kwargs.get("user_object_id", None) + self.user_tenant_id = kwargs.get("user_tenant_id", None) + self.user_name = kwargs.get("user_name", None) + + +class CreatedBy1(msrest.serialization.Model): + """CreatedBy1. + + All required parameters must be populated in order to send to Azure. + + :ivar user_object_id: Required. + :vartype user_object_id: str + :ivar user_tenant_id: Required. + :vartype user_tenant_id: str + :ivar user_name: Required. + :vartype user_name: str + """ + + _validation = { + "user_object_id": {"required": True}, + "user_tenant_id": {"required": True}, + "user_name": {"required": True}, + } + + _attribute_map = { + "user_object_id": {"key": "userObjectId", "type": "str"}, + "user_tenant_id": {"key": "userTenantId", "type": "str"}, + "user_name": {"key": "userName", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword user_object_id: Required. + :paramtype user_object_id: str + :keyword user_tenant_id: Required. + :paramtype user_tenant_id: str + :keyword user_name: Required. + :paramtype user_name: str + """ + super(CreatedBy1, self).__init__(**kwargs) + self.user_object_id = kwargs["user_object_id"] + self.user_tenant_id = kwargs["user_tenant_id"] + self.user_name = kwargs["user_name"] + + +class CreationContext(msrest.serialization.Model): + """CreationContext. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar created_time: + :vartype created_time: ~datetime.datetime + :ivar created_by: + :vartype created_by: ~index_service_apis.models.CreatedBy + :ivar creation_source: + :vartype creation_source: str + """ + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "created_time": {"key": "createdTime", "type": "iso-8601"}, + "created_by": {"key": "createdBy", "type": "CreatedBy"}, + "creation_source": {"key": "creationSource", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword created_time: + :paramtype created_time: ~datetime.datetime + :keyword created_by: + :paramtype created_by: ~index_service_apis.models.CreatedBy + :keyword creation_source: + :paramtype creation_source: str + """ + super(CreationContext, self).__init__(**kwargs) + self.additional_properties = kwargs.get("additional_properties", None) + self.created_time = kwargs.get("created_time", None) + self.created_by = kwargs.get("created_by", None) + self.creation_source = kwargs.get("creation_source", None) + + +class CronTrigger(msrest.serialization.Model): + """CronTrigger. + + :ivar expression: + :vartype expression: str + """ + + _attribute_map = { + "expression": {"key": "expression", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword expression: + :paramtype expression: str + """ + super(CronTrigger, self).__init__(**kwargs) + self.expression = kwargs.get("expression", None) + + +class CrossRegionIndexEntitiesRequest(msrest.serialization.Model): + """CrossRegionIndexEntitiesRequest. + + :ivar resource_ids: + :vartype resource_ids: list[~index_service_apis.models.ResourceInformation] + :ivar index_entities_request: + :vartype index_entities_request: ~index_service_apis.models.IndexEntitiesRequest + """ + + _attribute_map = { + "resource_ids": {"key": "resourceIds", "type": "[ResourceInformation]"}, + "index_entities_request": {"key": "indexEntitiesRequest", "type": "IndexEntitiesRequest"}, + } + + def __init__(self, **kwargs): + """ + :keyword resource_ids: + :paramtype resource_ids: list[~index_service_apis.models.ResourceInformation] + :keyword index_entities_request: + :paramtype index_entities_request: ~index_service_apis.models.IndexEntitiesRequest + """ + super(CrossRegionIndexEntitiesRequest, self).__init__(**kwargs) + self.resource_ids = kwargs.get("resource_ids", None) + self.index_entities_request = kwargs.get("index_entities_request", None) + + +class CrossRegionIndexEntitiesResponse(msrest.serialization.Model): + """CrossRegionIndexEntitiesResponse. + + :ivar index_entities_response: + :vartype index_entities_response: ~index_service_apis.models.IndexEntitiesResponse + :ivar regional_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype regional_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar shard_errors: Dictionary of + <components·1fu9hkf·schemas·crossregionindexentitiesresponse·properties·sharderrors·additionalproperties>. + :vartype shard_errors: dict[str, dict[str, ~index_service_apis.models.ErrorResponse]] + :ivar number_of_resources_not_included_in_search: + :vartype number_of_resources_not_included_in_search: int + """ + + _attribute_map = { + "index_entities_response": {"key": "indexEntitiesResponse", "type": "IndexEntitiesResponse"}, + "regional_errors": {"key": "regionalErrors", "type": "{ErrorResponse}"}, + "shard_errors": {"key": "shardErrors", "type": "{{ErrorResponse}}"}, + "number_of_resources_not_included_in_search": {"key": "numberOfResourcesNotIncludedInSearch", "type": "int"}, + } + + def __init__(self, **kwargs): + """ + :keyword index_entities_response: + :paramtype index_entities_response: ~index_service_apis.models.IndexEntitiesResponse + :keyword regional_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype regional_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword shard_errors: Dictionary of + <components·1fu9hkf·schemas·crossregionindexentitiesresponse·properties·sharderrors·additionalproperties>. + :paramtype shard_errors: dict[str, dict[str, ~index_service_apis.models.ErrorResponse]] + :keyword number_of_resources_not_included_in_search: + :paramtype number_of_resources_not_included_in_search: int + """ + super(CrossRegionIndexEntitiesResponse, self).__init__(**kwargs) + self.index_entities_response = kwargs.get("index_entities_response", None) + self.regional_errors = kwargs.get("regional_errors", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.number_of_resources_not_included_in_search = kwargs.get("number_of_resources_not_included_in_search", None) + + +class CudaAttribute(msrest.serialization.Model): + """CudaAttribute. + + All required parameters must be populated in order to send to Azure. + + :ivar cuda_version: Required. + :vartype cuda_version: str + :ivar cu_dnn_version: Required. + :vartype cu_dnn_version: str + :ivar nccl_version: Required. + :vartype nccl_version: str + """ + + _validation = { + "cuda_version": {"required": True}, + "cu_dnn_version": {"required": True}, + "nccl_version": {"required": True}, + } + + _attribute_map = { + "cuda_version": {"key": "cudaVersion", "type": "str"}, + "cu_dnn_version": {"key": "cuDnnVersion", "type": "str"}, + "nccl_version": {"key": "ncclVersion", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword cuda_version: Required. + :paramtype cuda_version: str + :keyword cu_dnn_version: Required. + :paramtype cu_dnn_version: str + :keyword nccl_version: Required. + :paramtype nccl_version: str + """ + super(CudaAttribute, self).__init__(**kwargs) + self.cuda_version = kwargs["cuda_version"] + self.cu_dnn_version = kwargs["cu_dnn_version"] + self.nccl_version = kwargs["nccl_version"] + + +class DatasetAnnotations(msrest.serialization.Model): + """DatasetAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar modified_time: Required. + :vartype modified_time: ~datetime.datetime + :ivar modified_by: Required. + :vartype modified_by: ~index_service_apis.models.UserDto + :ivar next_version_id: Required. + :vartype next_version_id: str + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar labels: Required. Dictionary of :code:`<string>`. + :vartype labels: dict[str, str] + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "modified_time": {"required": True}, + "modified_by": {"required": True}, + "next_version_id": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "labels": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "modified_time": {"key": "modifiedTime", "type": "iso-8601"}, + "modified_by": {"key": "modifiedBy", "type": "UserDto"}, + "next_version_id": {"key": "nextVersionId", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "labels": {"key": "labels", "type": "{str}"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword modified_time: Required. + :paramtype modified_time: ~datetime.datetime + :keyword modified_by: Required. + :paramtype modified_by: ~index_service_apis.models.UserDto + :keyword next_version_id: Required. + :paramtype next_version_id: str + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword labels: Required. Dictionary of :code:`<string>`. + :paramtype labels: dict[str, str] + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(DatasetAnnotations, self).__init__(**kwargs) + self.modified_time = kwargs["modified_time"] + self.modified_by = kwargs["modified_by"] + self.next_version_id = kwargs["next_version_id"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.labels = kwargs["labels"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class DatasetProperties(msrest.serialization.Model): + """DatasetProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar subtype: Required. + :vartype subtype: str + :ivar is_registered: Required. + :vartype is_registered: bool + :ivar data_type: Required. + :vartype data_type: str + :ivar is_v2: Required. + :vartype is_v2: bool + :ivar name_lower_case: Required. + :vartype name_lower_case: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "subtype": {"required": True}, + "is_registered": {"required": True}, + "data_type": {"required": True}, + "is_v2": {"required": True}, + "name_lower_case": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "subtype": {"key": "subtype", "type": "str"}, + "is_registered": {"key": "isRegistered", "type": "bool"}, + "data_type": {"key": "dataType", "type": "str"}, + "is_v2": {"key": "isV2", "type": "bool"}, + "name_lower_case": {"key": "nameLowerCase", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword subtype: Required. + :paramtype subtype: str + :keyword is_registered: Required. + :paramtype is_registered: bool + :keyword data_type: Required. + :paramtype data_type: str + :keyword is_v2: Required. + :paramtype is_v2: bool + :keyword name_lower_case: Required. + :paramtype name_lower_case: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(DatasetProperties, self).__init__(**kwargs) + self.subtype = kwargs["subtype"] + self.is_registered = kwargs["is_registered"] + self.data_type = kwargs["data_type"] + self.is_v2 = kwargs["is_v2"] + self.name_lower_case = kwargs["name_lower_case"] + self.creation_context = kwargs["creation_context"] + + +class DatasetReference(msrest.serialization.Model): + """DatasetReference. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar id: Required. + :vartype id: str + """ + + _validation = { + "name": {"required": True}, + "id": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "id": {"key": "id", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword id: Required. + :paramtype id: str + """ + super(DatasetReference, self).__init__(**kwargs) + self.name = kwargs["name"] + self.id = kwargs["id"] + + +class DatasetsVersionedEntitiesResponse(msrest.serialization.Model): + """DatasetsVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.DatasetsVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[DatasetsVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.DatasetsVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(DatasetsVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class DatasetsVersionedEntity(msrest.serialization.Model): + """DatasetsVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.DatasetsVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.DatasetAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.DatasetProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "DatasetAnnotations"}, + "properties": {"key": "properties", "type": "DatasetProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.DatasetsVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.DatasetAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.DatasetProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(DatasetsVersionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class DataStoreAnnotations(msrest.serialization.Model): + """DataStoreAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar data_store_type: Required. Possible values include: "AzureBlob", "AzureFile", + "GlusterFs", "AzureDataLake", "AzureMySql", "Custom", "Hdfs", "AzureSqlDatabase", + "AzurePostgreSql", "DBFS", "AzureDataLakeGen2". + :vartype data_store_type: str or ~index_service_apis.models.DataStoreAnnotationsDataStoreType + :ivar data_store_type_name: Required. + :vartype data_store_type_name: str + :ivar storage_name: Required. + :vartype storage_name: str + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "data_store_type": {"required": True}, + "data_store_type_name": {"required": True}, + "storage_name": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "data_store_type": {"key": "dataStoreType", "type": "str"}, + "data_store_type_name": {"key": "dataStoreTypeName", "type": "str"}, + "storage_name": {"key": "storageName", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword data_store_type: Required. Possible values include: "AzureBlob", "AzureFile", + "GlusterFs", "AzureDataLake", "AzureMySql", "Custom", "Hdfs", "AzureSqlDatabase", + "AzurePostgreSql", "DBFS", "AzureDataLakeGen2". + :paramtype data_store_type: str or ~index_service_apis.models.DataStoreAnnotationsDataStoreType + :keyword data_store_type_name: Required. + :paramtype data_store_type_name: str + :keyword storage_name: Required. + :paramtype storage_name: str + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(DataStoreAnnotations, self).__init__(**kwargs) + self.data_store_type = kwargs["data_store_type"] + self.data_store_type_name = kwargs["data_store_type_name"] + self.storage_name = kwargs["storage_name"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class DataStoreProperties(msrest.serialization.Model): + """DataStoreProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "creation_context": {"required": True}, + } + + _attribute_map = { + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(DataStoreProperties, self).__init__(**kwargs) + self.creation_context = kwargs["creation_context"] + + +class DatastoresUnversionedEntitiesResponse(msrest.serialization.Model): + """DatastoresUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.DatastoresUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[DatastoresUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.DatastoresUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(DatastoresUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class DatastoresUnversionedEntity(msrest.serialization.Model): + """DatastoresUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.DatastoresUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.DataStoreAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.DataStoreProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "DataStoreAnnotations"}, + "properties": {"key": "properties", "type": "DataStoreProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.DatastoresUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.DataStoreAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.DataStoreProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(DatastoresUnversionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class DebugInfoResponse(msrest.serialization.Model): + """DebugInfoResponse. + + :ivar type: + :vartype type: str + :ivar message: + :vartype message: str + :ivar stack_trace: + :vartype stack_trace: str + :ivar inner_exception: + :vartype inner_exception: ~index_service_apis.models.DebugInfoResponse + :ivar data: Dictionary of :code:`<any>`. + :vartype data: dict[str, any] + :ivar error_response: + :vartype error_response: ~index_service_apis.models.ErrorResponse + """ + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "stack_trace": {"key": "stackTrace", "type": "str"}, + "inner_exception": {"key": "innerException", "type": "DebugInfoResponse"}, + "data": {"key": "data", "type": "{object}"}, + "error_response": {"key": "errorResponse", "type": "ErrorResponse"}, + } + + def __init__(self, **kwargs): + """ + :keyword type: + :paramtype type: str + :keyword message: + :paramtype message: str + :keyword stack_trace: + :paramtype stack_trace: str + :keyword inner_exception: + :paramtype inner_exception: ~index_service_apis.models.DebugInfoResponse + :keyword data: Dictionary of :code:`<any>`. + :paramtype data: dict[str, any] + :keyword error_response: + :paramtype error_response: ~index_service_apis.models.ErrorResponse + """ + super(DebugInfoResponse, self).__init__(**kwargs) + self.type = kwargs.get("type", None) + self.message = kwargs.get("message", None) + self.stack_trace = kwargs.get("stack_trace", None) + self.inner_exception = kwargs.get("inner_exception", None) + self.data = kwargs.get("data", None) + self.error_response = kwargs.get("error_response", None) + + +class DefinitionAnnotations(msrest.serialization.Model): + """DefinitionAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(DefinitionAnnotations, self).__init__(**kwargs) + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class DefinitionProperties(msrest.serialization.Model): + """DefinitionProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar automatically_saved: Required. + :vartype automatically_saved: bool + :ivar definition_hash: Required. + :vartype definition_hash: str + :ivar environment_attributes: Required. + :vartype environment_attributes: ~index_service_apis.models.EnvironmentAttributes + :ivar stage: Required. + :vartype stage: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "automatically_saved": {"required": True}, + "definition_hash": {"required": True}, + "environment_attributes": {"required": True}, + "stage": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "automatically_saved": {"key": "automaticallySaved", "type": "bool"}, + "definition_hash": {"key": "definitionHash", "type": "str"}, + "environment_attributes": {"key": "environmentAttributes", "type": "EnvironmentAttributes"}, + "stage": {"key": "stage", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword automatically_saved: Required. + :paramtype automatically_saved: bool + :keyword definition_hash: Required. + :paramtype definition_hash: str + :keyword environment_attributes: Required. + :paramtype environment_attributes: ~index_service_apis.models.EnvironmentAttributes + :keyword stage: Required. + :paramtype stage: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(DefinitionProperties, self).__init__(**kwargs) + self.automatically_saved = kwargs["automatically_saved"] + self.definition_hash = kwargs["definition_hash"] + self.environment_attributes = kwargs["environment_attributes"] + self.stage = kwargs["stage"] + self.creation_context = kwargs["creation_context"] + + +class EndpointComputeTarget(msrest.serialization.Model): + """EndpointComputeTarget. + + All required parameters must be populated in order to send to Azure. + + :ivar namespace: Required. + :vartype namespace: str + :ivar compute_target_name: Required. + :vartype compute_target_name: str + """ + + _validation = { + "namespace": {"required": True}, + "compute_target_name": {"required": True}, + } + + _attribute_map = { + "namespace": {"key": "namespace", "type": "str"}, + "compute_target_name": {"key": "computeTargetName", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword namespace: Required. + :paramtype namespace: str + :keyword compute_target_name: Required. + :paramtype compute_target_name: str + """ + super(EndpointComputeTarget, self).__init__(**kwargs) + self.namespace = kwargs["namespace"] + self.compute_target_name = kwargs["compute_target_name"] + + +class EnvironmentAttributes(msrest.serialization.Model): + """EnvironmentAttributes. + + All required parameters must be populated in order to send to Azure. + + :ivar machine_learning_framework: Required. + :vartype machine_learning_framework: ~index_service_apis.models.VersionedAttribute + :ivar mpi: Required. + :vartype mpi: ~index_service_apis.models.VersionedAttribute + :ivar runtime: Required. + :vartype runtime: ~index_service_apis.models.VersionedAttribute + :ivar cuda: Required. + :vartype cuda: ~index_service_apis.models.CudaAttribute + :ivar purpose: Required. + :vartype purpose: ~index_service_apis.models.Purpose + :ivar os: Required. + :vartype os: ~index_service_apis.models.VersionedAttribute + """ + + _validation = { + "machine_learning_framework": {"required": True}, + "mpi": {"required": True}, + "runtime": {"required": True}, + "cuda": {"required": True}, + "purpose": {"required": True}, + "os": {"required": True}, + } + + _attribute_map = { + "machine_learning_framework": {"key": "machineLearningFramework", "type": "VersionedAttribute"}, + "mpi": {"key": "mpi", "type": "VersionedAttribute"}, + "runtime": {"key": "runtime", "type": "VersionedAttribute"}, + "cuda": {"key": "cuda", "type": "CudaAttribute"}, + "purpose": {"key": "purpose", "type": "Purpose"}, + "os": {"key": "os", "type": "VersionedAttribute"}, + } + + def __init__(self, **kwargs): + """ + :keyword machine_learning_framework: Required. + :paramtype machine_learning_framework: ~index_service_apis.models.VersionedAttribute + :keyword mpi: Required. + :paramtype mpi: ~index_service_apis.models.VersionedAttribute + :keyword runtime: Required. + :paramtype runtime: ~index_service_apis.models.VersionedAttribute + :keyword cuda: Required. + :paramtype cuda: ~index_service_apis.models.CudaAttribute + :keyword purpose: Required. + :paramtype purpose: ~index_service_apis.models.Purpose + :keyword os: Required. + :paramtype os: ~index_service_apis.models.VersionedAttribute + """ + super(EnvironmentAttributes, self).__init__(**kwargs) + self.machine_learning_framework = kwargs["machine_learning_framework"] + self.mpi = kwargs["mpi"] + self.runtime = kwargs["runtime"] + self.cuda = kwargs["cuda"] + self.purpose = kwargs["purpose"] + self.os = kwargs["os"] + + +class EnvironmentsVersionedEntitiesResponse(msrest.serialization.Model): + """EnvironmentsVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.EnvironmentsVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[EnvironmentsVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.EnvironmentsVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(EnvironmentsVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class EnvironmentsVersionedEntity(msrest.serialization.Model): + """EnvironmentsVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.EnvironmentsVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.DefinitionAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.DefinitionProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "DefinitionAnnotations"}, + "properties": {"key": "properties", "type": "DefinitionProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.EnvironmentsVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.DefinitionAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.DefinitionProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(EnvironmentsVersionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class ErrorAdditionalInfo(msrest.serialization.Model): + """ErrorAdditionalInfo. + + :ivar type: + :vartype type: str + :ivar info: Anything. + :vartype info: any + """ + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "info": {"key": "info", "type": "object"}, + } + + def __init__(self, **kwargs): + """ + :keyword type: + :paramtype type: str + :keyword info: Anything. + :paramtype info: any + """ + super(ErrorAdditionalInfo, self).__init__(**kwargs) + self.type = kwargs.get("type", None) + self.info = kwargs.get("info", None) + + +class ErrorResponse(msrest.serialization.Model): + """ErrorResponse. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar error: + :vartype error: ~index_service_apis.models.RootError + :ivar correlation: Dictionary of :code:`<string>`. + :vartype correlation: dict[str, str] + :ivar environment: + :vartype environment: str + :ivar location: + :vartype location: str + :ivar time: + :vartype time: ~datetime.datetime + :ivar component_name: + :vartype component_name: str + """ + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "error": {"key": "error", "type": "RootError"}, + "correlation": {"key": "correlation", "type": "{str}"}, + "environment": {"key": "environment", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "time": {"key": "time", "type": "iso-8601"}, + "component_name": {"key": "componentName", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword error: + :paramtype error: ~index_service_apis.models.RootError + :keyword correlation: Dictionary of :code:`<string>`. + :paramtype correlation: dict[str, str] + :keyword environment: + :paramtype environment: str + :keyword location: + :paramtype location: str + :keyword time: + :paramtype time: ~datetime.datetime + :keyword component_name: + :paramtype component_name: str + """ + super(ErrorResponse, self).__init__(**kwargs) + self.additional_properties = kwargs.get("additional_properties", None) + self.error = kwargs.get("error", None) + self.correlation = kwargs.get("correlation", None) + self.environment = kwargs.get("environment", None) + self.location = kwargs.get("location", None) + self.time = kwargs.get("time", None) + self.component_name = kwargs.get("component_name", None) + + +class ExperimentStatus(msrest.serialization.Model): + """ExperimentStatus. + + :ivar status_code: Possible values include: "NotStarted", "Running", "Failed", "Finished", + "Canceled", "Failing". + :vartype status_code: str or ~index_service_apis.models.ExperimentStatusCode + :ivar status_detail: + :vartype status_detail: str + :ivar creation_time: + :vartype creation_time: ~datetime.datetime + :ivar end_time: + :vartype end_time: ~datetime.datetime + :ivar run_history_error_code: + :vartype run_history_error_code: str + """ + + _attribute_map = { + "status_code": {"key": "statusCode", "type": "str"}, + "status_detail": {"key": "statusDetail", "type": "str"}, + "creation_time": {"key": "creationTime", "type": "iso-8601"}, + "end_time": {"key": "endTime", "type": "iso-8601"}, + "run_history_error_code": {"key": "runHistoryErrorCode", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword status_code: Possible values include: "NotStarted", "Running", "Failed", "Finished", + "Canceled", "Failing". + :paramtype status_code: str or ~index_service_apis.models.ExperimentStatusCode + :keyword status_detail: + :paramtype status_detail: str + :keyword creation_time: + :paramtype creation_time: ~datetime.datetime + :keyword end_time: + :paramtype end_time: ~datetime.datetime + :keyword run_history_error_code: + :paramtype run_history_error_code: str + """ + super(ExperimentStatus, self).__init__(**kwargs) + self.status_code = kwargs.get("status_code", None) + self.status_detail = kwargs.get("status_detail", None) + self.creation_time = kwargs.get("creation_time", None) + self.end_time = kwargs.get("end_time", None) + self.run_history_error_code = kwargs.get("run_history_error_code", None) + + +class Feature(msrest.serialization.Model): + """Feature. + + All required parameters must be populated in order to send to Azure. + + :ivar feature_name: Required. + :vartype feature_name: str + :ivar description: Required. + :vartype description: str + :ivar data_type: Required. Possible values include: "String", "Integer", "Long", "Float", + "Double", "Binary", "Datetime", "Boolean". + :vartype data_type: str or ~index_service_apis.models.FeatureDataType + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "feature_name": {"required": True}, + "description": {"required": True}, + "data_type": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "feature_name": {"key": "featureName", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "data_type": {"key": "dataType", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword feature_name: Required. + :paramtype feature_name: str + :keyword description: Required. + :paramtype description: str + :keyword data_type: Required. Possible values include: "String", "Integer", "Long", "Float", + "Double", "Binary", "Datetime", "Boolean". + :paramtype data_type: str or ~index_service_apis.models.FeatureDataType + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(Feature, self).__init__(**kwargs) + self.feature_name = kwargs["feature_name"] + self.description = kwargs["description"] + self.data_type = kwargs["data_type"] + self.tags = kwargs["tags"] + + +class FeatureentitiesVersionedEntitiesResponse(msrest.serialization.Model): + """FeatureentitiesVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.FeatureentitiesVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[FeatureentitiesVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.FeatureentitiesVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(FeatureentitiesVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class FeatureentitiesVersionedEntity(msrest.serialization.Model): + """FeatureentitiesVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.FeatureentitiesVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.FeatureEntityVersionProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "FeatureEntityVersionAnnotations"}, + "properties": {"key": "properties", "type": "FeatureEntityVersionProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.FeatureentitiesVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.FeatureEntityVersionProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(FeatureentitiesVersionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class FeatureEntityVersionAnnotations(msrest.serialization.Model): + """FeatureEntityVersionAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar actual_name: Required. + :vartype actual_name: str + :ivar index_columns: Required. + :vartype index_columns: list[~index_service_apis.models.IndexColumnDto] + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "actual_name": {"required": True}, + "index_columns": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "actual_name": {"key": "actualName", "type": "str"}, + "index_columns": {"key": "indexColumns", "type": "[IndexColumnDto]"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword actual_name: Required. + :paramtype actual_name: str + :keyword index_columns: Required. + :paramtype index_columns: list[~index_service_apis.models.IndexColumnDto] + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(FeatureEntityVersionAnnotations, self).__init__(**kwargs) + self.actual_name = kwargs["actual_name"] + self.index_columns = kwargs["index_columns"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class FeatureEntityVersionProperties(msrest.serialization.Model): + """FeatureEntityVersionProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar feature_entity_name: Required. + :vartype feature_entity_name: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "feature_entity_name": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "feature_entity_name": {"key": "featureEntityName", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword feature_entity_name: Required. + :paramtype feature_entity_name: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(FeatureEntityVersionProperties, self).__init__(**kwargs) + self.feature_entity_name = kwargs["feature_entity_name"] + self.creation_context = kwargs["creation_context"] + + +class FeaturesetSpecification(msrest.serialization.Model): + """FeaturesetSpecification. + + All required parameters must be populated in order to send to Azure. + + :ivar path: Required. + :vartype path: str + """ + + _validation = { + "path": {"required": True}, + } + + _attribute_map = { + "path": {"key": "path", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword path: Required. + :paramtype path: str + """ + super(FeaturesetSpecification, self).__init__(**kwargs) + self.path = kwargs["path"] + + +class FeaturesetsVersionedEntitiesResponse(msrest.serialization.Model): + """FeaturesetsVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.FeaturesetsVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[FeaturesetsVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.FeaturesetsVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(FeaturesetsVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class FeaturesetsVersionedEntity(msrest.serialization.Model): + """FeaturesetsVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.FeaturesetsVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.FeatureSetVersionAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.FeatureSetVersionProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "FeatureSetVersionAnnotations"}, + "properties": {"key": "properties", "type": "FeatureSetVersionProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.FeaturesetsVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.FeatureSetVersionAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.FeatureSetVersionProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(FeaturesetsVersionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class FeatureSetVersionAnnotations(msrest.serialization.Model): + """FeatureSetVersionAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar actual_name: Required. + :vartype actual_name: str + :ivar specification: Required. + :vartype specification: ~index_service_apis.models.FeaturesetSpecification + :ivar entities: Required. + :vartype entities: list[str] + :ivar features: Required. + :vartype features: list[~index_service_apis.models.Feature] + :ivar stage: Required. + :vartype stage: str + :ivar materialization_settings: Required. + :vartype materialization_settings: ~index_service_apis.models.MaterializationSettings + :ivar source: Required. + :vartype source: ~index_service_apis.models.FeatureSourceDto + :ivar feature_transformation_code: Required. + :vartype feature_transformation_code: ~index_service_apis.models.FeatureTransformationDto + :ivar temporal_join_lookback: Required. + :vartype temporal_join_lookback: ~index_service_apis.models.TimeDeltaDto + :ivar source_lookback: Required. + :vartype source_lookback: ~index_service_apis.models.TimeDeltaDto + :ivar timestamp_column: Required. + :vartype timestamp_column: ~index_service_apis.models.TimestampColumnDto + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "actual_name": {"required": True}, + "specification": {"required": True}, + "entities": {"required": True}, + "features": {"required": True}, + "stage": {"required": True}, + "materialization_settings": {"required": True}, + "source": {"required": True}, + "feature_transformation_code": {"required": True}, + "temporal_join_lookback": {"required": True}, + "source_lookback": {"required": True}, + "timestamp_column": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "actual_name": {"key": "actualName", "type": "str"}, + "specification": {"key": "specification", "type": "FeaturesetSpecification"}, + "entities": {"key": "entities", "type": "[str]"}, + "features": {"key": "features", "type": "[Feature]"}, + "stage": {"key": "stage", "type": "str"}, + "materialization_settings": {"key": "materializationSettings", "type": "MaterializationSettings"}, + "source": {"key": "source", "type": "FeatureSourceDto"}, + "feature_transformation_code": {"key": "featureTransformationCode", "type": "FeatureTransformationDto"}, + "temporal_join_lookback": {"key": "temporalJoinLookback", "type": "TimeDeltaDto"}, + "source_lookback": {"key": "sourceLookback", "type": "TimeDeltaDto"}, + "timestamp_column": {"key": "timestampColumn", "type": "TimestampColumnDto"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword actual_name: Required. + :paramtype actual_name: str + :keyword specification: Required. + :paramtype specification: ~index_service_apis.models.FeaturesetSpecification + :keyword entities: Required. + :paramtype entities: list[str] + :keyword features: Required. + :paramtype features: list[~index_service_apis.models.Feature] + :keyword stage: Required. + :paramtype stage: str + :keyword materialization_settings: Required. + :paramtype materialization_settings: ~index_service_apis.models.MaterializationSettings + :keyword source: Required. + :paramtype source: ~index_service_apis.models.FeatureSourceDto + :keyword feature_transformation_code: Required. + :paramtype feature_transformation_code: ~index_service_apis.models.FeatureTransformationDto + :keyword temporal_join_lookback: Required. + :paramtype temporal_join_lookback: ~index_service_apis.models.TimeDeltaDto + :keyword source_lookback: Required. + :paramtype source_lookback: ~index_service_apis.models.TimeDeltaDto + :keyword timestamp_column: Required. + :paramtype timestamp_column: ~index_service_apis.models.TimestampColumnDto + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(FeatureSetVersionAnnotations, self).__init__(**kwargs) + self.actual_name = kwargs["actual_name"] + self.specification = kwargs["specification"] + self.entities = kwargs["entities"] + self.features = kwargs["features"] + self.stage = kwargs["stage"] + self.materialization_settings = kwargs["materialization_settings"] + self.source = kwargs["source"] + self.feature_transformation_code = kwargs["feature_transformation_code"] + self.temporal_join_lookback = kwargs["temporal_join_lookback"] + self.source_lookback = kwargs["source_lookback"] + self.timestamp_column = kwargs["timestamp_column"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class FeatureSetVersionProperties(msrest.serialization.Model): + """FeatureSetVersionProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar feature_set_name: Required. + :vartype feature_set_name: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "feature_set_name": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "feature_set_name": {"key": "featureSetName", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword feature_set_name: Required. + :paramtype feature_set_name: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(FeatureSetVersionProperties, self).__init__(**kwargs) + self.feature_set_name = kwargs["feature_set_name"] + self.creation_context = kwargs["creation_context"] + + +class FeatureSourceDto(msrest.serialization.Model): + """FeatureSourceDto. + + All required parameters must be populated in order to send to Azure. + + :ivar type: Required. Possible values include: "mltable", "csv", "parquet". + :vartype type: str or ~index_service_apis.models.FeatureSourceDtoType + :ivar path: Required. + :vartype path: str + :ivar timestamp_column: Required. + :vartype timestamp_column: ~index_service_apis.models.TimestampColumnDto + :ivar source_delay: Required. + :vartype source_delay: ~index_service_apis.models.TimeDeltaDto + """ + + _validation = { + "type": {"required": True}, + "path": {"required": True}, + "timestamp_column": {"required": True}, + "source_delay": {"required": True}, + } + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "path": {"key": "path", "type": "str"}, + "timestamp_column": {"key": "timestampColumn", "type": "TimestampColumnDto"}, + "source_delay": {"key": "sourceDelay", "type": "TimeDeltaDto"}, + } + + def __init__(self, **kwargs): + """ + :keyword type: Required. Possible values include: "mltable", "csv", "parquet". + :paramtype type: str or ~index_service_apis.models.FeatureSourceDtoType + :keyword path: Required. + :paramtype path: str + :keyword timestamp_column: Required. + :paramtype timestamp_column: ~index_service_apis.models.TimestampColumnDto + :keyword source_delay: Required. + :paramtype source_delay: ~index_service_apis.models.TimeDeltaDto + """ + super(FeatureSourceDto, self).__init__(**kwargs) + self.type = kwargs["type"] + self.path = kwargs["path"] + self.timestamp_column = kwargs["timestamp_column"] + self.source_delay = kwargs["source_delay"] + + +class FeaturestoreentitiesVersionedEntitiesResponse(msrest.serialization.Model): + """FeaturestoreentitiesVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.FeaturestoreentitiesVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[FeaturestoreentitiesVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.FeaturestoreentitiesVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(FeaturestoreentitiesVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class FeaturestoreentitiesVersionedEntity(msrest.serialization.Model): + """FeaturestoreentitiesVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.FeaturestoreentitiesVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.FeatureEntityVersionProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "FeatureEntityVersionAnnotations"}, + "properties": {"key": "properties", "type": "FeatureEntityVersionProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.FeaturestoreentitiesVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.FeatureEntityVersionProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(FeaturestoreentitiesVersionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class FeatureTransformationDto(msrest.serialization.Model): + """FeatureTransformationDto. + + All required parameters must be populated in order to send to Azure. + + :ivar path: Required. + :vartype path: str + :ivar transformer_class: Required. + :vartype transformer_class: str + """ + + _validation = { + "path": {"required": True}, + "transformer_class": {"required": True}, + } + + _attribute_map = { + "path": {"key": "path", "type": "str"}, + "transformer_class": {"key": "transformerClass", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword path: Required. + :paramtype path: str + :keyword transformer_class: Required. + :paramtype transformer_class: str + """ + super(FeatureTransformationDto, self).__init__(**kwargs) + self.path = kwargs["path"] + self.transformer_class = kwargs["transformer_class"] + + +class FreeTextSearchColumn(msrest.serialization.Model): + """FreeTextSearchColumn. + + :ivar name: + :vartype name: str + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: + :paramtype name: str + """ + super(FreeTextSearchColumn, self).__init__(**kwargs) + self.name = kwargs.get("name", None) + + +class GenericTriggerAnnotations(msrest.serialization.Model): + """GenericTriggerAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar display_name: Required. + :vartype display_name: str + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar provisioning_status: Required. Possible values include: "Completed", "Provisioning", + "Failed". + :vartype provisioning_status: str or + ~index_service_apis.models.GenericTriggerAnnotationsProvisioningStatus + :ivar trigger_type: Required. Possible values include: "Schedule", "Once". + :vartype trigger_type: str or ~index_service_apis.models.GenericTriggerAnnotationsTriggerType + :ivar schedule_method: Required. Possible values include: "Cron", "Recurrence". + :vartype schedule_method: str or + ~index_service_apis.models.GenericTriggerAnnotationsScheduleMethod + :ivar schedule_action_type: Required. Possible values include: "CreateJob", "InvokeEndpoint", + "ImportData", "ModelMonitor". + :vartype schedule_action_type: str or + ~index_service_apis.models.GenericTriggerAnnotationsScheduleActionType + :ivar recurrence: Required. + :vartype recurrence: ~index_service_apis.models.RecurrenceTrigger + :ivar cron: Required. + :vartype cron: ~index_service_apis.models.CronTrigger + :ivar start_time: Required. + :vartype start_time: str + :ivar end_time: Required. + :vartype end_time: str + :ivar time_zone: Required. + :vartype time_zone: str + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.GenericTriggerAnnotationsEntityStatus + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar last_updated_by: Required. + :vartype last_updated_by: ~index_service_apis.models.CreatedBy + :ivar definition: Required. + :vartype definition: str + :ivar feature_definition: Required. + :vartype feature_definition: str + :ivar managed_type: Required. Possible values include: "Customer", "System". + :vartype managed_type: str or ~index_service_apis.models.GenericTriggerAnnotationsManagedType + :ivar scenario_name: Required. + :vartype scenario_name: str + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "display_name": {"required": True}, + "kv_tags": {"required": True}, + "properties": {"required": True}, + "provisioning_status": {"required": True}, + "trigger_type": {"required": True}, + "schedule_method": {"required": True}, + "schedule_action_type": {"required": True}, + "recurrence": {"required": True}, + "cron": {"required": True}, + "start_time": {"required": True}, + "end_time": {"required": True}, + "time_zone": {"required": True}, + "entity_status": {"required": True}, + "last_modified_date": {"required": True}, + "last_updated_by": {"required": True}, + "definition": {"required": True}, + "feature_definition": {"required": True}, + "managed_type": {"required": True}, + "scenario_name": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "display_name": {"key": "displayName", "type": "str"}, + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "provisioning_status": {"key": "provisioningStatus", "type": "str"}, + "trigger_type": {"key": "triggerType", "type": "str"}, + "schedule_method": {"key": "scheduleMethod", "type": "str"}, + "schedule_action_type": {"key": "scheduleActionType", "type": "str"}, + "recurrence": {"key": "recurrence", "type": "RecurrenceTrigger"}, + "cron": {"key": "cron", "type": "CronTrigger"}, + "start_time": {"key": "startTime", "type": "str"}, + "end_time": {"key": "endTime", "type": "str"}, + "time_zone": {"key": "timeZone", "type": "str"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"}, + "definition": {"key": "definition", "type": "str"}, + "feature_definition": {"key": "featureDefinition", "type": "str"}, + "managed_type": {"key": "managedType", "type": "str"}, + "scenario_name": {"key": "scenarioName", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword display_name: Required. + :paramtype display_name: str + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword provisioning_status: Required. Possible values include: "Completed", "Provisioning", + "Failed". + :paramtype provisioning_status: str or + ~index_service_apis.models.GenericTriggerAnnotationsProvisioningStatus + :keyword trigger_type: Required. Possible values include: "Schedule", "Once". + :paramtype trigger_type: str or ~index_service_apis.models.GenericTriggerAnnotationsTriggerType + :keyword schedule_method: Required. Possible values include: "Cron", "Recurrence". + :paramtype schedule_method: str or + ~index_service_apis.models.GenericTriggerAnnotationsScheduleMethod + :keyword schedule_action_type: Required. Possible values include: "CreateJob", + "InvokeEndpoint", "ImportData", "ModelMonitor". + :paramtype schedule_action_type: str or + ~index_service_apis.models.GenericTriggerAnnotationsScheduleActionType + :keyword recurrence: Required. + :paramtype recurrence: ~index_service_apis.models.RecurrenceTrigger + :keyword cron: Required. + :paramtype cron: ~index_service_apis.models.CronTrigger + :keyword start_time: Required. + :paramtype start_time: str + :keyword end_time: Required. + :paramtype end_time: str + :keyword time_zone: Required. + :paramtype time_zone: str + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or + ~index_service_apis.models.GenericTriggerAnnotationsEntityStatus + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword last_updated_by: Required. + :paramtype last_updated_by: ~index_service_apis.models.CreatedBy + :keyword definition: Required. + :paramtype definition: str + :keyword feature_definition: Required. + :paramtype feature_definition: str + :keyword managed_type: Required. Possible values include: "Customer", "System". + :paramtype managed_type: str or ~index_service_apis.models.GenericTriggerAnnotationsManagedType + :keyword scenario_name: Required. + :paramtype scenario_name: str + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(GenericTriggerAnnotations, self).__init__(**kwargs) + self.display_name = kwargs["display_name"] + self.kv_tags = kwargs["kv_tags"] + self.properties = kwargs["properties"] + self.provisioning_status = kwargs["provisioning_status"] + self.trigger_type = kwargs["trigger_type"] + self.schedule_method = kwargs["schedule_method"] + self.schedule_action_type = kwargs["schedule_action_type"] + self.recurrence = kwargs["recurrence"] + self.cron = kwargs["cron"] + self.start_time = kwargs["start_time"] + self.end_time = kwargs["end_time"] + self.time_zone = kwargs["time_zone"] + self.entity_status = kwargs["entity_status"] + self.last_modified_date = kwargs["last_modified_date"] + self.last_updated_by = kwargs["last_updated_by"] + self.definition = kwargs["definition"] + self.feature_definition = kwargs["feature_definition"] + self.managed_type = kwargs["managed_type"] + self.scenario_name = kwargs["scenario_name"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class GenericTriggerProperties(msrest.serialization.Model): + """GenericTriggerProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(GenericTriggerProperties, self).__init__(**kwargs) + self.id = kwargs["id"] + self.creation_context = kwargs["creation_context"] + + +class GenerictriggersUnversionedEntitiesResponse(msrest.serialization.Model): + """GenerictriggersUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.GenerictriggersUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[GenerictriggersUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.GenerictriggersUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(GenerictriggersUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class GenerictriggersUnversionedEntity(msrest.serialization.Model): + """GenerictriggersUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.GenerictriggersUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.GenericTriggerAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.GenericTriggerProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "GenericTriggerAnnotations"}, + "properties": {"key": "properties", "type": "GenericTriggerProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.GenerictriggersUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.GenericTriggerAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.GenericTriggerProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(GenerictriggersUnversionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class HighlightOptions(msrest.serialization.Model): + """HighlightOptions. + + :ivar pre_tag: + :vartype pre_tag: str + :ivar post_tag: + :vartype post_tag: str + :ivar fields: + :vartype fields: list[str] + """ + + _attribute_map = { + "pre_tag": {"key": "preTag", "type": "str"}, + "post_tag": {"key": "postTag", "type": "str"}, + "fields": {"key": "fields", "type": "[str]"}, + } + + def __init__(self, **kwargs): + """ + :keyword pre_tag: + :paramtype pre_tag: str + :keyword post_tag: + :paramtype post_tag: str + :keyword fields: + :paramtype fields: list[str] + """ + super(HighlightOptions, self).__init__(**kwargs) + self.pre_tag = kwargs.get("pre_tag", None) + self.post_tag = kwargs.get("post_tag", None) + self.fields = kwargs.get("fields", None) + + +class IndependentPipelineAnnotations(msrest.serialization.Model): + """IndependentPipelineAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar url: Required. + :vartype url: str + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar step_tags: Required. Dictionary of :code:`<string>`. + :vartype step_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar step_properties: Required. Dictionary of :code:`<string>`. + :vartype step_properties: dict[str, str] + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or + ~index_service_apis.models.IndependentPipelineAnnotationsEntityStatus + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar last_updated_by: Required. + :vartype last_updated_by: ~index_service_apis.models.CreatedBy + :ivar last_run_id: Required. + :vartype last_run_id: str + :ivar pipeline_type: Required. + :vartype pipeline_type: str + :ivar last_run_status_code: Required. Possible values include: "NotStarted", "Running", + "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested". + :vartype last_run_status_code: str or + ~index_service_apis.models.IndependentPipelineAnnotationsLastRunStatusCode + :ivar last_run_creation_time: Required. + :vartype last_run_creation_time: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "url": {"required": True}, + "kv_tags": {"required": True}, + "step_tags": {"required": True}, + "properties": {"required": True}, + "step_properties": {"required": True}, + "entity_status": {"required": True}, + "last_modified_date": {"required": True}, + "last_updated_by": {"required": True}, + "last_run_id": {"required": True}, + "pipeline_type": {"required": True}, + "last_run_status_code": {"required": True}, + "last_run_creation_time": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "url": {"key": "url", "type": "str"}, + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "step_tags": {"key": "stepTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "step_properties": {"key": "stepProperties", "type": "{str}"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"}, + "last_run_id": {"key": "lastRunId", "type": "str"}, + "pipeline_type": {"key": "pipelineType", "type": "str"}, + "last_run_status_code": {"key": "lastRunStatusCode", "type": "str"}, + "last_run_creation_time": {"key": "lastRunCreationTime", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword url: Required. + :paramtype url: str + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword step_tags: Required. Dictionary of :code:`<string>`. + :paramtype step_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword step_properties: Required. Dictionary of :code:`<string>`. + :paramtype step_properties: dict[str, str] + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or + ~index_service_apis.models.IndependentPipelineAnnotationsEntityStatus + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword last_updated_by: Required. + :paramtype last_updated_by: ~index_service_apis.models.CreatedBy + :keyword last_run_id: Required. + :paramtype last_run_id: str + :keyword pipeline_type: Required. + :paramtype pipeline_type: str + :keyword last_run_status_code: Required. Possible values include: "NotStarted", "Running", + "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested". + :paramtype last_run_status_code: str or + ~index_service_apis.models.IndependentPipelineAnnotationsLastRunStatusCode + :keyword last_run_creation_time: Required. + :paramtype last_run_creation_time: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(IndependentPipelineAnnotations, self).__init__(**kwargs) + self.url = kwargs["url"] + self.kv_tags = kwargs["kv_tags"] + self.step_tags = kwargs["step_tags"] + self.properties = kwargs["properties"] + self.step_properties = kwargs["step_properties"] + self.entity_status = kwargs["entity_status"] + self.last_modified_date = kwargs["last_modified_date"] + self.last_updated_by = kwargs["last_updated_by"] + self.last_run_id = kwargs["last_run_id"] + self.pipeline_type = kwargs["pipeline_type"] + self.last_run_status_code = kwargs["last_run_status_code"] + self.last_run_creation_time = kwargs["last_run_creation_time"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class IndependentPipelineProperties(msrest.serialization.Model): + """IndependentPipelineProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(IndependentPipelineProperties, self).__init__(**kwargs) + self.id = kwargs["id"] + self.creation_context = kwargs["creation_context"] + + +class IndependentpipelinesUnversionedEntitiesResponse(msrest.serialization.Model): + """IndependentpipelinesUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.IndependentpipelinesUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[IndependentpipelinesUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.IndependentpipelinesUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(IndependentpipelinesUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class IndependentpipelinesUnversionedEntity(msrest.serialization.Model): + """IndependentpipelinesUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.IndependentpipelinesUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.IndependentPipelineAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.IndependentPipelineProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "IndependentPipelineAnnotations"}, + "properties": {"key": "properties", "type": "IndependentPipelineProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.IndependentpipelinesUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.IndependentPipelineAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.IndependentPipelineProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(IndependentpipelinesUnversionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class IndexAnnotations(msrest.serialization.Model): + """IndexAnnotations. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar archived: + :vartype archived: bool + :ivar tags: A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword archived: + :paramtype archived: bool + :keyword tags: A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(IndexAnnotations, self).__init__(**kwargs) + self.additional_properties = kwargs.get("additional_properties", None) + self.archived = kwargs.get("archived", None) + self.tags = kwargs.get("tags", None) + + +class IndexColumn(msrest.serialization.Model): + """IndexColumn. + + All required parameters must be populated in order to send to Azure. + + :ivar data_type: Required. Possible values include: "String", "Integer", "Long", "Float", + "Double", "Binary", "Datetime", "Boolean". + :vartype data_type: str or ~index_service_apis.models.IndexColumnDataType + :ivar column_name: Required. + :vartype column_name: str + """ + + _validation = { + "data_type": {"required": True}, + "column_name": {"required": True}, + } + + _attribute_map = { + "data_type": {"key": "dataType", "type": "str"}, + "column_name": {"key": "columnName", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword data_type: Required. Possible values include: "String", "Integer", "Long", "Float", + "Double", "Binary", "Datetime", "Boolean". + :paramtype data_type: str or ~index_service_apis.models.IndexColumnDataType + :keyword column_name: Required. + :paramtype column_name: str + """ + super(IndexColumn, self).__init__(**kwargs) + self.data_type = kwargs["data_type"] + self.column_name = kwargs["column_name"] + + +class IndexColumnDto(msrest.serialization.Model): + """IndexColumnDto. + + All required parameters must be populated in order to send to Azure. + + :ivar type: Required. Possible values include: "string", "integer", "long", "float", "double", + "binary", "datetime", "boolean". + :vartype type: str or ~index_service_apis.models.IndexColumnDtoType + :ivar name: Required. + :vartype name: str + """ + + _validation = { + "type": {"required": True}, + "name": {"required": True}, + } + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "name": {"key": "name", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword type: Required. Possible values include: "string", "integer", "long", "float", + "double", "binary", "datetime", "boolean". + :paramtype type: str or ~index_service_apis.models.IndexColumnDtoType + :keyword name: Required. + :paramtype name: str + """ + super(IndexColumnDto, self).__init__(**kwargs) + self.type = kwargs["type"] + self.name = kwargs["name"] + + +class IndexedErrorResponse(msrest.serialization.Model): + """IndexedErrorResponse. + + All required parameters must be populated in order to send to Azure. + + :ivar code: Required. + :vartype code: str + :ivar error_code_hierarchy: Required. + :vartype error_code_hierarchy: str + :ivar message: Required. + :vartype message: str + :ivar time: Required. + :vartype time: ~datetime.datetime + :ivar component_name: Required. + :vartype component_name: str + :ivar severity: Required. + :vartype severity: int + :ivar details_uri: Required. + :vartype details_uri: str + :ivar reference_code: Required. + :vartype reference_code: str + """ + + _validation = { + "code": {"required": True}, + "error_code_hierarchy": {"required": True}, + "message": {"required": True}, + "time": {"required": True}, + "component_name": {"required": True}, + "severity": {"required": True}, + "details_uri": {"required": True}, + "reference_code": {"required": True}, + } + + _attribute_map = { + "code": {"key": "code", "type": "str"}, + "error_code_hierarchy": {"key": "errorCodeHierarchy", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "time": {"key": "time", "type": "iso-8601"}, + "component_name": {"key": "componentName", "type": "str"}, + "severity": {"key": "severity", "type": "int"}, + "details_uri": {"key": "detailsUri", "type": "str"}, + "reference_code": {"key": "referenceCode", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword code: Required. + :paramtype code: str + :keyword error_code_hierarchy: Required. + :paramtype error_code_hierarchy: str + :keyword message: Required. + :paramtype message: str + :keyword time: Required. + :paramtype time: ~datetime.datetime + :keyword component_name: Required. + :paramtype component_name: str + :keyword severity: Required. + :paramtype severity: int + :keyword details_uri: Required. + :paramtype details_uri: str + :keyword reference_code: Required. + :paramtype reference_code: str + """ + super(IndexedErrorResponse, self).__init__(**kwargs) + self.code = kwargs["code"] + self.error_code_hierarchy = kwargs["error_code_hierarchy"] + self.message = kwargs["message"] + self.time = kwargs["time"] + self.component_name = kwargs["component_name"] + self.severity = kwargs["severity"] + self.details_uri = kwargs["details_uri"] + self.reference_code = kwargs["reference_code"] + + +class IndexEntitiesLocalOperationRequest(msrest.serialization.Model): + """IndexEntitiesLocalOperationRequest. + + :ivar get_all_entities: + :vartype get_all_entities: bool + :ivar group: + :vartype group: list[~index_service_apis.models.IndexEntitiesRequestGroup] + :ivar highlight_options: + :vartype highlight_options: ~index_service_apis.models.HighlightOptions + :ivar search_builder: + :vartype search_builder: str + :ivar search_mode: + :vartype search_mode: str + :ivar free_text_search: + :vartype free_text_search: str + :ivar free_text_search_columns: + :vartype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn] + :ivar filters: + :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar asset_resource_filters: + :vartype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar order: + :vartype order: list[~index_service_apis.models.IndexEntitiesRequestOrder] + :ivar page_size: + :vartype page_size: int + :ivar skip: + :vartype skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar include_total_result_count: + :vartype include_total_result_count: bool + :ivar resources: + :vartype resources: list[~index_service_apis.models.ResourceInformation] + :ivar cmk_fanout: + :vartype cmk_fanout: bool + :ivar include_fanout_data: + :vartype include_fanout_data: bool + :ivar shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData] + """ + + _attribute_map = { + "get_all_entities": {"key": "getAllEntities", "type": "bool"}, + "group": {"key": "group", "type": "[IndexEntitiesRequestGroup]"}, + "highlight_options": {"key": "highlightOptions", "type": "HighlightOptions"}, + "search_builder": {"key": "searchBuilder", "type": "str"}, + "search_mode": {"key": "searchMode", "type": "str"}, + "free_text_search": {"key": "freeTextSearch", "type": "str"}, + "free_text_search_columns": {"key": "freeTextSearchColumns", "type": "[FreeTextSearchColumn]"}, + "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"}, + "asset_resource_filters": {"key": "assetResourceFilters", "type": "[IndexEntitiesRequestFilter]"}, + "order": {"key": "order", "type": "[IndexEntitiesRequestOrder]"}, + "page_size": {"key": "pageSize", "type": "int"}, + "skip": {"key": "skip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "include_total_result_count": {"key": "includeTotalResultCount", "type": "bool"}, + "resources": {"key": "resources", "type": "[ResourceInformation]"}, + "cmk_fanout": {"key": "cmkFanout", "type": "bool"}, + "include_fanout_data": {"key": "includeFanoutData", "type": "bool"}, + "shard_id_to_shard_skips": {"key": "shardIdToShardSkips", "type": "{SingleShardFanoutData}"}, + } + + def __init__(self, **kwargs): + """ + :keyword get_all_entities: + :paramtype get_all_entities: bool + :keyword group: + :paramtype group: list[~index_service_apis.models.IndexEntitiesRequestGroup] + :keyword highlight_options: + :paramtype highlight_options: ~index_service_apis.models.HighlightOptions + :keyword search_builder: + :paramtype search_builder: str + :keyword search_mode: + :paramtype search_mode: str + :keyword free_text_search: + :paramtype free_text_search: str + :keyword free_text_search_columns: + :paramtype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn] + :keyword filters: + :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword asset_resource_filters: + :paramtype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword order: + :paramtype order: list[~index_service_apis.models.IndexEntitiesRequestOrder] + :keyword page_size: + :paramtype page_size: int + :keyword skip: + :paramtype skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword include_total_result_count: + :paramtype include_total_result_count: bool + :keyword resources: + :paramtype resources: list[~index_service_apis.models.ResourceInformation] + :keyword cmk_fanout: + :paramtype cmk_fanout: bool + :keyword include_fanout_data: + :paramtype include_fanout_data: bool + :keyword shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData] + """ + super(IndexEntitiesLocalOperationRequest, self).__init__(**kwargs) + self.get_all_entities = kwargs.get("get_all_entities", None) + self.group = kwargs.get("group", None) + self.highlight_options = kwargs.get("highlight_options", None) + self.search_builder = kwargs.get("search_builder", None) + self.search_mode = kwargs.get("search_mode", None) + self.free_text_search = kwargs.get("free_text_search", None) + self.free_text_search_columns = kwargs.get("free_text_search_columns", None) + self.filters = kwargs.get("filters", None) + self.asset_resource_filters = kwargs.get("asset_resource_filters", None) + self.order = kwargs.get("order", None) + self.page_size = kwargs.get("page_size", None) + self.skip = kwargs.get("skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.include_total_result_count = kwargs.get("include_total_result_count", None) + self.resources = kwargs.get("resources", None) + self.cmk_fanout = kwargs.get("cmk_fanout", None) + self.include_fanout_data = kwargs.get("include_fanout_data", None) + self.shard_id_to_shard_skips = kwargs.get("shard_id_to_shard_skips", None) + + +class IndexEntitiesRequest(msrest.serialization.Model): + """IndexEntitiesRequest. + + :ivar highlight_options: + :vartype highlight_options: ~index_service_apis.models.HighlightOptions + :ivar search_builder: + :vartype search_builder: str + :ivar search_mode: + :vartype search_mode: str + :ivar free_text_search: + :vartype free_text_search: str + :ivar free_text_search_columns: + :vartype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn] + :ivar filters: + :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar asset_resource_filters: + :vartype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar order: + :vartype order: list[~index_service_apis.models.IndexEntitiesRequestOrder] + :ivar page_size: + :vartype page_size: int + :ivar skip: + :vartype skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar include_total_result_count: + :vartype include_total_result_count: bool + :ivar resources: + :vartype resources: list[~index_service_apis.models.ResourceInformation] + :ivar cmk_fanout: + :vartype cmk_fanout: bool + :ivar include_fanout_data: + :vartype include_fanout_data: bool + :ivar shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData] + """ + + _attribute_map = { + "highlight_options": {"key": "highlightOptions", "type": "HighlightOptions"}, + "search_builder": {"key": "searchBuilder", "type": "str"}, + "search_mode": {"key": "searchMode", "type": "str"}, + "free_text_search": {"key": "freeTextSearch", "type": "str"}, + "free_text_search_columns": {"key": "freeTextSearchColumns", "type": "[FreeTextSearchColumn]"}, + "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"}, + "asset_resource_filters": {"key": "assetResourceFilters", "type": "[IndexEntitiesRequestFilter]"}, + "order": {"key": "order", "type": "[IndexEntitiesRequestOrder]"}, + "page_size": {"key": "pageSize", "type": "int"}, + "skip": {"key": "skip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "include_total_result_count": {"key": "includeTotalResultCount", "type": "bool"}, + "resources": {"key": "resources", "type": "[ResourceInformation]"}, + "cmk_fanout": {"key": "cmkFanout", "type": "bool"}, + "include_fanout_data": {"key": "includeFanoutData", "type": "bool"}, + "shard_id_to_shard_skips": {"key": "shardIdToShardSkips", "type": "{SingleShardFanoutData}"}, + } + + def __init__(self, **kwargs): + """ + :keyword highlight_options: + :paramtype highlight_options: ~index_service_apis.models.HighlightOptions + :keyword search_builder: + :paramtype search_builder: str + :keyword search_mode: + :paramtype search_mode: str + :keyword free_text_search: + :paramtype free_text_search: str + :keyword free_text_search_columns: + :paramtype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn] + :keyword filters: + :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword asset_resource_filters: + :paramtype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword order: + :paramtype order: list[~index_service_apis.models.IndexEntitiesRequestOrder] + :keyword page_size: + :paramtype page_size: int + :keyword skip: + :paramtype skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword include_total_result_count: + :paramtype include_total_result_count: bool + :keyword resources: + :paramtype resources: list[~index_service_apis.models.ResourceInformation] + :keyword cmk_fanout: + :paramtype cmk_fanout: bool + :keyword include_fanout_data: + :paramtype include_fanout_data: bool + :keyword shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData] + """ + super(IndexEntitiesRequest, self).__init__(**kwargs) + self.highlight_options = kwargs.get("highlight_options", None) + self.search_builder = kwargs.get("search_builder", None) + self.search_mode = kwargs.get("search_mode", None) + self.free_text_search = kwargs.get("free_text_search", None) + self.free_text_search_columns = kwargs.get("free_text_search_columns", None) + self.filters = kwargs.get("filters", None) + self.asset_resource_filters = kwargs.get("asset_resource_filters", None) + self.order = kwargs.get("order", None) + self.page_size = kwargs.get("page_size", None) + self.skip = kwargs.get("skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.include_total_result_count = kwargs.get("include_total_result_count", None) + self.resources = kwargs.get("resources", None) + self.cmk_fanout = kwargs.get("cmk_fanout", None) + self.include_fanout_data = kwargs.get("include_fanout_data", None) + self.shard_id_to_shard_skips = kwargs.get("shard_id_to_shard_skips", None) + + +class IndexEntitiesRequestFilter(msrest.serialization.Model): + """IndexEntitiesRequestFilter. + + :ivar field: + :vartype field: str + :ivar operator: + :vartype operator: str + :ivar values: + :vartype values: list[str] + """ + + _attribute_map = { + "field": {"key": "field", "type": "str"}, + "operator": {"key": "operator", "type": "str"}, + "values": {"key": "values", "type": "[str]"}, + } + + def __init__(self, **kwargs): + """ + :keyword field: + :paramtype field: str + :keyword operator: + :paramtype operator: str + :keyword values: + :paramtype values: list[str] + """ + super(IndexEntitiesRequestFilter, self).__init__(**kwargs) + self.field = kwargs.get("field", None) + self.operator = kwargs.get("operator", None) + self.values = kwargs.get("values", None) + + +class IndexEntitiesRequestGroup(msrest.serialization.Model): + """IndexEntitiesRequestGroup. + + :ivar field: + :vartype field: str + """ + + _attribute_map = { + "field": {"key": "field", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword field: + :paramtype field: str + """ + super(IndexEntitiesRequestGroup, self).__init__(**kwargs) + self.field = kwargs.get("field", None) + + +class IndexEntitiesRequestOrder(msrest.serialization.Model): + """IndexEntitiesRequestOrder. + + :ivar field: + :vartype field: str + :ivar direction: Possible values include: "Asc", "Desc". + :vartype direction: str or ~index_service_apis.models.IndexEntitiesRequestOrderDirection + """ + + _attribute_map = { + "field": {"key": "field", "type": "str"}, + "direction": {"key": "direction", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword field: + :paramtype field: str + :keyword direction: Possible values include: "Asc", "Desc". + :paramtype direction: str or ~index_service_apis.models.IndexEntitiesRequestOrderDirection + """ + super(IndexEntitiesRequestOrder, self).__init__(**kwargs) + self.field = kwargs.get("field", None) + self.direction = kwargs.get("direction", None) + + +class IndexEntitiesResponse(msrest.serialization.Model): + """IndexEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.IndexEntityResponse] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[IndexEntityResponse]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.IndexEntityResponse] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(IndexEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class IndexEntityContainerMetadata(msrest.serialization.Model): + """IndexEntityContainerMetadata. + + :ivar resource_id: + :vartype resource_id: str + :ivar subscription_id: + :vartype subscription_id: str + :ivar resource_group: + :vartype resource_group: str + :ivar resource_name: + :vartype resource_name: str + :ivar entity_container_type: + :vartype entity_container_type: str + :ivar regions: + :vartype regions: list[~index_service_apis.models.ResourceRegion] + :ivar tenant_id: + :vartype tenant_id: str + :ivar immutable_resource_id: + :vartype immutable_resource_id: str + :ivar is_public_resource: + :vartype is_public_resource: bool + """ + + _attribute_map = { + "resource_id": {"key": "resourceId", "type": "str"}, + "subscription_id": {"key": "subscriptionId", "type": "str"}, + "resource_group": {"key": "resourceGroup", "type": "str"}, + "resource_name": {"key": "resourceName", "type": "str"}, + "entity_container_type": {"key": "entityContainerType", "type": "str"}, + "regions": {"key": "regions", "type": "[ResourceRegion]"}, + "tenant_id": {"key": "tenantId", "type": "str"}, + "immutable_resource_id": {"key": "immutableResourceId", "type": "str"}, + "is_public_resource": {"key": "isPublicResource", "type": "bool"}, + } + + def __init__(self, **kwargs): + """ + :keyword resource_id: + :paramtype resource_id: str + :keyword subscription_id: + :paramtype subscription_id: str + :keyword resource_group: + :paramtype resource_group: str + :keyword resource_name: + :paramtype resource_name: str + :keyword entity_container_type: + :paramtype entity_container_type: str + :keyword regions: + :paramtype regions: list[~index_service_apis.models.ResourceRegion] + :keyword tenant_id: + :paramtype tenant_id: str + :keyword immutable_resource_id: + :paramtype immutable_resource_id: str + :keyword is_public_resource: + :paramtype is_public_resource: bool + """ + super(IndexEntityContainerMetadata, self).__init__(**kwargs) + self.resource_id = kwargs.get("resource_id", None) + self.subscription_id = kwargs.get("subscription_id", None) + self.resource_group = kwargs.get("resource_group", None) + self.resource_name = kwargs.get("resource_name", None) + self.entity_container_type = kwargs.get("entity_container_type", None) + self.regions = kwargs.get("regions", None) + self.tenant_id = kwargs.get("tenant_id", None) + self.immutable_resource_id = kwargs.get("immutable_resource_id", None) + self.is_public_resource = kwargs.get("is_public_resource", None) + + +class IndexEntityResponse(msrest.serialization.Model): + """IndexEntityResponse. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar relevancy_score: + :vartype relevancy_score: float + :ivar entity_resource_name: + :vartype entity_resource_name: str + :ivar highlights: Dictionary of + <components·jiilq·schemas·indexentityresponse·properties·highlights·additionalproperties>. + :vartype highlights: dict[str, list[str]] + :ivar usage: + :vartype usage: ~index_service_apis.models.Usage + :ivar schema_id: + :vartype schema_id: str + :ivar entity_id: + :vartype entity_id: str + :ivar kind: Possible values include: "Invalid", "LineageRoot", "Versioned", "Unversioned". + :vartype kind: str or ~index_service_apis.models.EntityKind + :ivar annotations: + :vartype annotations: ~index_service_apis.models.IndexAnnotations + :ivar properties: + :vartype properties: ~index_service_apis.models.IndexProperties + :ivar internal: Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: + :vartype update_sequence: long + :ivar type: + :vartype type: str + :ivar version: + :vartype version: str + :ivar entity_container_id: + :vartype entity_container_id: str + :ivar entity_object_id: + :vartype entity_object_id: str + :ivar resource_type: + :vartype resource_type: str + :ivar relationships: + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "version": {"readonly": True}, + "entity_container_id": {"readonly": True}, + "entity_object_id": {"readonly": True}, + "resource_type": {"readonly": True}, + } + + _attribute_map = { + "relevancy_score": {"key": "relevancyScore", "type": "float"}, + "entity_resource_name": {"key": "entityResourceName", "type": "str"}, + "highlights": {"key": "highlights", "type": "{[str]}"}, + "usage": {"key": "usage", "type": "Usage"}, + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "IndexAnnotations"}, + "properties": {"key": "properties", "type": "IndexProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "long"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword relevancy_score: + :paramtype relevancy_score: float + :keyword entity_resource_name: + :paramtype entity_resource_name: str + :keyword highlights: Dictionary of + <components·jiilq·schemas·indexentityresponse·properties·highlights·additionalproperties>. + :paramtype highlights: dict[str, list[str]] + :keyword usage: + :paramtype usage: ~index_service_apis.models.Usage + :keyword schema_id: + :paramtype schema_id: str + :keyword entity_id: + :paramtype entity_id: str + :keyword kind: Possible values include: "Invalid", "LineageRoot", "Versioned", "Unversioned". + :paramtype kind: str or ~index_service_apis.models.EntityKind + :keyword annotations: + :paramtype annotations: ~index_service_apis.models.IndexAnnotations + :keyword properties: + :paramtype properties: ~index_service_apis.models.IndexProperties + :keyword internal: Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: + :paramtype update_sequence: long + :keyword type: + :paramtype type: str + :keyword relationships: + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(IndexEntityResponse, self).__init__(**kwargs) + self.relevancy_score = kwargs.get("relevancy_score", None) + self.entity_resource_name = kwargs.get("entity_resource_name", None) + self.highlights = kwargs.get("highlights", None) + self.usage = kwargs.get("usage", None) + self.schema_id = kwargs.get("schema_id", None) + self.entity_id = kwargs.get("entity_id", None) + self.kind = kwargs.get("kind", None) + self.annotations = kwargs.get("annotations", None) + self.properties = kwargs.get("properties", None) + self.internal = kwargs.get("internal", None) + self.update_sequence = kwargs.get("update_sequence", None) + self.type = kwargs.get("type", None) + self.version = None + self.entity_container_id = None + self.entity_object_id = None + self.resource_type = None + self.relationships = kwargs.get("relationships", None) + self.asset_id = kwargs.get("asset_id", None) + + +class IndexProperties(msrest.serialization.Model): + """IndexProperties. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar updated_time: + :vartype updated_time: ~datetime.datetime + :ivar creation_context: + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "updated_time": {"key": "updatedTime", "type": "iso-8601"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword updated_time: + :paramtype updated_time: ~datetime.datetime + :keyword creation_context: + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(IndexProperties, self).__init__(**kwargs) + self.additional_properties = kwargs.get("additional_properties", None) + self.updated_time = kwargs.get("updated_time", None) + self.creation_context = kwargs.get("creation_context", None) + + +class IndexResourceDiscoveryResponseItem(msrest.serialization.Model): + """IndexResourceDiscoveryResponseItem. + + :ivar name: + :vartype name: str + :ivar resource_id: + :vartype resource_id: str + :ivar resource_type: + :vartype resource_type: str + :ivar region: + :vartype region: str + :ivar regions: + :vartype regions: list[~index_service_apis.models.ResourceRegion] + :ivar subscription_id: + :vartype subscription_id: str + :ivar resource_group_name: + :vartype resource_group_name: str + :ivar tags: A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + :ivar is_customer_managed: + :vartype is_customer_managed: bool + :ivar is_private_link_resource: + :vartype is_private_link_resource: bool + :ivar is_private_link_resource_behind_vnet: + :vartype is_private_link_resource_behind_vnet: bool + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "region": {"key": "region", "type": "str"}, + "regions": {"key": "regions", "type": "[ResourceRegion]"}, + "subscription_id": {"key": "subscriptionId", "type": "str"}, + "resource_group_name": {"key": "resourceGroupName", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "is_customer_managed": {"key": "isCustomerManaged", "type": "bool"}, + "is_private_link_resource": {"key": "isPrivateLinkResource", "type": "bool"}, + "is_private_link_resource_behind_vnet": {"key": "isPrivateLinkResourceBehindVnet", "type": "bool"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: + :paramtype name: str + :keyword resource_id: + :paramtype resource_id: str + :keyword resource_type: + :paramtype resource_type: str + :keyword region: + :paramtype region: str + :keyword regions: + :paramtype regions: list[~index_service_apis.models.ResourceRegion] + :keyword subscription_id: + :paramtype subscription_id: str + :keyword resource_group_name: + :paramtype resource_group_name: str + :keyword tags: A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + :keyword is_customer_managed: + :paramtype is_customer_managed: bool + :keyword is_private_link_resource: + :paramtype is_private_link_resource: bool + :keyword is_private_link_resource_behind_vnet: + :paramtype is_private_link_resource_behind_vnet: bool + """ + super(IndexResourceDiscoveryResponseItem, self).__init__(**kwargs) + self.name = kwargs.get("name", None) + self.resource_id = kwargs.get("resource_id", None) + self.resource_type = kwargs.get("resource_type", None) + self.region = kwargs.get("region", None) + self.regions = kwargs.get("regions", None) + self.subscription_id = kwargs.get("subscription_id", None) + self.resource_group_name = kwargs.get("resource_group_name", None) + self.tags = kwargs.get("tags", None) + self.is_customer_managed = kwargs.get("is_customer_managed", None) + self.is_private_link_resource = kwargs.get("is_private_link_resource", None) + self.is_private_link_resource_behind_vnet = kwargs.get("is_private_link_resource_behind_vnet", None) + + +class IndexResourceDiscoveryResponseItemPaginatedResult(msrest.serialization.Model): + """IndexResourceDiscoveryResponseItemPaginatedResult. + + :ivar value: + :vartype value: list[~index_service_apis.models.IndexResourceDiscoveryResponseItem] + :ivar continuation_token: + :vartype continuation_token: str + :ivar next_link: + :vartype next_link: str + """ + + _attribute_map = { + "value": {"key": "value", "type": "[IndexResourceDiscoveryResponseItem]"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword value: + :paramtype value: list[~index_service_apis.models.IndexResourceDiscoveryResponseItem] + :keyword continuation_token: + :paramtype continuation_token: str + :keyword next_link: + :paramtype next_link: str + """ + super(IndexResourceDiscoveryResponseItemPaginatedResult, self).__init__(**kwargs) + self.value = kwargs.get("value", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.next_link = kwargs.get("next_link", None) + + +class InnerErrorResponse(msrest.serialization.Model): + """InnerErrorResponse. + + :ivar code: + :vartype code: str + :ivar inner_error: + :vartype inner_error: ~index_service_apis.models.InnerErrorResponse + """ + + _attribute_map = { + "code": {"key": "code", "type": "str"}, + "inner_error": {"key": "innerError", "type": "InnerErrorResponse"}, + } + + def __init__(self, **kwargs): + """ + :keyword code: + :paramtype code: str + :keyword inner_error: + :paramtype inner_error: ~index_service_apis.models.InnerErrorResponse + """ + super(InnerErrorResponse, self).__init__(**kwargs) + self.code = kwargs.get("code", None) + self.inner_error = kwargs.get("inner_error", None) + + +class InputNameAndDataTypeIdsList(msrest.serialization.Model): + """InputNameAndDataTypeIdsList. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar data_type_ids_list: Required. + :vartype data_type_ids_list: list[str] + :ivar is_optional: Required. + :vartype is_optional: bool + :ivar description: Required. + :vartype description: str + :ivar label: Required. + :vartype label: str + """ + + _validation = { + "name": {"required": True}, + "data_type_ids_list": {"required": True}, + "is_optional": {"required": True}, + "description": {"required": True}, + "label": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "data_type_ids_list": {"key": "dataTypeIdsList", "type": "[str]"}, + "is_optional": {"key": "isOptional", "type": "bool"}, + "description": {"key": "description", "type": "str"}, + "label": {"key": "label", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword data_type_ids_list: Required. + :paramtype data_type_ids_list: list[str] + :keyword is_optional: Required. + :paramtype is_optional: bool + :keyword description: Required. + :paramtype description: str + :keyword label: Required. + :paramtype label: str + """ + super(InputNameAndDataTypeIdsList, self).__init__(**kwargs) + self.name = kwargs["name"] + self.data_type_ids_list = kwargs["data_type_ids_list"] + self.is_optional = kwargs["is_optional"] + self.description = kwargs["description"] + self.label = kwargs["label"] + + +class InternalUxPresenceWarmUpRequest(msrest.serialization.Model): + """InternalUxPresenceWarmUpRequest. + + :ivar resources: + :vartype resources: list[~index_service_apis.models.UxPresenceResource] + :ivar source_ip: + :vartype source_ip: str + :ivar user_tenant_id: + :vartype user_tenant_id: str + :ivar user_object_id: + :vartype user_object_id: str + """ + + _attribute_map = { + "resources": {"key": "resources", "type": "[UxPresenceResource]"}, + "source_ip": {"key": "sourceIp", "type": "str"}, + "user_tenant_id": {"key": "userTenantId", "type": "str"}, + "user_object_id": {"key": "userObjectId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword resources: + :paramtype resources: list[~index_service_apis.models.UxPresenceResource] + :keyword source_ip: + :paramtype source_ip: str + :keyword user_tenant_id: + :paramtype user_tenant_id: str + :keyword user_object_id: + :paramtype user_object_id: str + """ + super(InternalUxPresenceWarmUpRequest, self).__init__(**kwargs) + self.resources = kwargs.get("resources", None) + self.source_ip = kwargs.get("source_ip", None) + self.user_tenant_id = kwargs.get("user_tenant_id", None) + self.user_object_id = kwargs.get("user_object_id", None) + + +class JobCost(msrest.serialization.Model): + """JobCost. + + All required parameters must be populated in order to send to Azure. + + :ivar charged_cpu_core_seconds: Required. + :vartype charged_cpu_core_seconds: float + :ivar charged_cpu_memory_megabyte_seconds: Required. + :vartype charged_cpu_memory_megabyte_seconds: float + :ivar charged_gpu_seconds: Required. + :vartype charged_gpu_seconds: float + :ivar charged_node_utilization_seconds: Required. + :vartype charged_node_utilization_seconds: float + """ + + _validation = { + "charged_cpu_core_seconds": {"required": True}, + "charged_cpu_memory_megabyte_seconds": {"required": True}, + "charged_gpu_seconds": {"required": True}, + "charged_node_utilization_seconds": {"required": True}, + } + + _attribute_map = { + "charged_cpu_core_seconds": {"key": "chargedCpuCoreSeconds", "type": "float"}, + "charged_cpu_memory_megabyte_seconds": {"key": "chargedCpuMemoryMegabyteSeconds", "type": "float"}, + "charged_gpu_seconds": {"key": "chargedGpuSeconds", "type": "float"}, + "charged_node_utilization_seconds": {"key": "chargedNodeUtilizationSeconds", "type": "float"}, + } + + def __init__(self, **kwargs): + """ + :keyword charged_cpu_core_seconds: Required. + :paramtype charged_cpu_core_seconds: float + :keyword charged_cpu_memory_megabyte_seconds: Required. + :paramtype charged_cpu_memory_megabyte_seconds: float + :keyword charged_gpu_seconds: Required. + :paramtype charged_gpu_seconds: float + :keyword charged_node_utilization_seconds: Required. + :paramtype charged_node_utilization_seconds: float + """ + super(JobCost, self).__init__(**kwargs) + self.charged_cpu_core_seconds = kwargs["charged_cpu_core_seconds"] + self.charged_cpu_memory_megabyte_seconds = kwargs["charged_cpu_memory_megabyte_seconds"] + self.charged_gpu_seconds = kwargs["charged_gpu_seconds"] + self.charged_node_utilization_seconds = kwargs["charged_node_utilization_seconds"] + + +class MaterializationComputeResource(msrest.serialization.Model): + """MaterializationComputeResource. + + All required parameters must be populated in order to send to Azure. + + :ivar instance_type: Required. + :vartype instance_type: str + """ + + _validation = { + "instance_type": {"required": True}, + } + + _attribute_map = { + "instance_type": {"key": "instanceType", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword instance_type: Required. + :paramtype instance_type: str + """ + super(MaterializationComputeResource, self).__init__(**kwargs) + self.instance_type = kwargs["instance_type"] + + +class MaterializationSettings(msrest.serialization.Model): + """MaterializationSettings. + + All required parameters must be populated in order to send to Azure. + + :ivar materialization_store_type: Required. Possible values include: "None", "Online", + "Offline", "OnlineAndOffline". + :vartype materialization_store_type: str or + ~index_service_apis.models.MaterializationSettingsMaterializationStoreType + :ivar schedule: Required. + :vartype schedule: ~index_service_apis.models.Recurrence + :ivar notification: + :vartype notification: ~index_service_apis.models.NotificationSetting + :ivar resource: Required. + :vartype resource: ~index_service_apis.models.MaterializationComputeResource + :ivar spark_configuration: Required. Dictionary of :code:`<string>`. + :vartype spark_configuration: dict[str, str] + """ + + _validation = { + "materialization_store_type": {"required": True}, + "schedule": {"required": True}, + "resource": {"required": True}, + "spark_configuration": {"required": True}, + } + + _attribute_map = { + "materialization_store_type": {"key": "materializationStoreType", "type": "str"}, + "schedule": {"key": "schedule", "type": "Recurrence"}, + "notification": {"key": "notification", "type": "NotificationSetting"}, + "resource": {"key": "resource", "type": "MaterializationComputeResource"}, + "spark_configuration": {"key": "sparkConfiguration", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword materialization_store_type: Required. Possible values include: "None", "Online", + "Offline", "OnlineAndOffline". + :paramtype materialization_store_type: str or + ~index_service_apis.models.MaterializationSettingsMaterializationStoreType + :keyword schedule: Required. + :paramtype schedule: ~index_service_apis.models.Recurrence + :keyword notification: + :paramtype notification: ~index_service_apis.models.NotificationSetting + :keyword resource: Required. + :paramtype resource: ~index_service_apis.models.MaterializationComputeResource + :keyword spark_configuration: Required. Dictionary of :code:`<string>`. + :paramtype spark_configuration: dict[str, str] + """ + super(MaterializationSettings, self).__init__(**kwargs) + self.materialization_store_type = kwargs["materialization_store_type"] + self.schedule = kwargs["schedule"] + self.notification = kwargs.get("notification", None) + self.resource = kwargs["resource"] + self.spark_configuration = kwargs["spark_configuration"] + + +class ModelAnnotations(msrest.serialization.Model): + """ModelAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar datasets: Required. + :vartype datasets: list[~index_service_apis.models.DatasetReference] + :ivar sample_input_data: Required. + :vartype sample_input_data: str + :ivar sample_output_data: Required. + :vartype sample_output_data: str + :ivar resource_requirements: Required. + :vartype resource_requirements: ~index_service_apis.models.ContainerResourceRequirements + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "datasets": {"required": True}, + "sample_input_data": {"required": True}, + "sample_output_data": {"required": True}, + "resource_requirements": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "datasets": {"key": "datasets", "type": "[DatasetReference]"}, + "sample_input_data": {"key": "sampleInputData", "type": "str"}, + "sample_output_data": {"key": "sampleOutputData", "type": "str"}, + "resource_requirements": {"key": "resourceRequirements", "type": "ContainerResourceRequirements"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword datasets: Required. + :paramtype datasets: list[~index_service_apis.models.DatasetReference] + :keyword sample_input_data: Required. + :paramtype sample_input_data: str + :keyword sample_output_data: Required. + :paramtype sample_output_data: str + :keyword resource_requirements: Required. + :paramtype resource_requirements: ~index_service_apis.models.ContainerResourceRequirements + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(ModelAnnotations, self).__init__(**kwargs) + self.datasets = kwargs["datasets"] + self.sample_input_data = kwargs["sample_input_data"] + self.sample_output_data = kwargs["sample_output_data"] + self.resource_requirements = kwargs["resource_requirements"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class ModelProperties(msrest.serialization.Model): + """ModelProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar name: Required. + :vartype name: str + :ivar model_framework: Required. + :vartype model_framework: str + :ivar model_framework_version: Required. + :vartype model_framework_version: str + :ivar model_format: Required. + :vartype model_format: str + :ivar version: Required. + :vartype version: int + :ivar alphanumeric_version: Required. + :vartype alphanumeric_version: str + :ivar url: Required. + :vartype url: str + :ivar mime_type: Required. + :vartype mime_type: str + :ivar modified_time: Required. + :vartype modified_time: ~datetime.datetime + :ivar unpack: Required. + :vartype unpack: bool + :ivar parent_model_id: Required. + :vartype parent_model_id: str + :ivar run_id: Required. + :vartype run_id: str + :ivar experiment_name: Required. + :vartype experiment_name: str + :ivar experiment_id: Required. + :vartype experiment_id: str + :ivar derived_model_ids: Required. + :vartype derived_model_ids: list[str] + :ivar user_properties: Required. Dictionary of :code:`<string>`. + :vartype user_properties: dict[str, str] + :ivar is_anonymous: Required. + :vartype is_anonymous: bool + :ivar orgin_asset_id: Required. + :vartype orgin_asset_id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "name": {"required": True}, + "model_framework": {"required": True}, + "model_framework_version": {"required": True}, + "model_format": {"required": True}, + "version": {"required": True}, + "alphanumeric_version": {"required": True}, + "url": {"required": True}, + "mime_type": {"required": True}, + "modified_time": {"required": True}, + "unpack": {"required": True}, + "parent_model_id": {"required": True}, + "run_id": {"required": True}, + "experiment_name": {"required": True}, + "experiment_id": {"required": True}, + "derived_model_ids": {"required": True}, + "user_properties": {"required": True}, + "is_anonymous": {"required": True}, + "orgin_asset_id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "model_framework": {"key": "modelFramework", "type": "str"}, + "model_framework_version": {"key": "modelFrameworkVersion", "type": "str"}, + "model_format": {"key": "modelFormat", "type": "str"}, + "version": {"key": "version", "type": "int"}, + "alphanumeric_version": {"key": "alphanumericVersion", "type": "str"}, + "url": {"key": "url", "type": "str"}, + "mime_type": {"key": "mimeType", "type": "str"}, + "modified_time": {"key": "modifiedTime", "type": "iso-8601"}, + "unpack": {"key": "unpack", "type": "bool"}, + "parent_model_id": {"key": "parentModelId", "type": "str"}, + "run_id": {"key": "runId", "type": "str"}, + "experiment_name": {"key": "experimentName", "type": "str"}, + "experiment_id": {"key": "experimentId", "type": "str"}, + "derived_model_ids": {"key": "derivedModelIds", "type": "[str]"}, + "user_properties": {"key": "userProperties", "type": "{str}"}, + "is_anonymous": {"key": "isAnonymous", "type": "bool"}, + "orgin_asset_id": {"key": "orginAssetId", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword name: Required. + :paramtype name: str + :keyword model_framework: Required. + :paramtype model_framework: str + :keyword model_framework_version: Required. + :paramtype model_framework_version: str + :keyword model_format: Required. + :paramtype model_format: str + :keyword version: Required. + :paramtype version: int + :keyword alphanumeric_version: Required. + :paramtype alphanumeric_version: str + :keyword url: Required. + :paramtype url: str + :keyword mime_type: Required. + :paramtype mime_type: str + :keyword modified_time: Required. + :paramtype modified_time: ~datetime.datetime + :keyword unpack: Required. + :paramtype unpack: bool + :keyword parent_model_id: Required. + :paramtype parent_model_id: str + :keyword run_id: Required. + :paramtype run_id: str + :keyword experiment_name: Required. + :paramtype experiment_name: str + :keyword experiment_id: Required. + :paramtype experiment_id: str + :keyword derived_model_ids: Required. + :paramtype derived_model_ids: list[str] + :keyword user_properties: Required. Dictionary of :code:`<string>`. + :paramtype user_properties: dict[str, str] + :keyword is_anonymous: Required. + :paramtype is_anonymous: bool + :keyword orgin_asset_id: Required. + :paramtype orgin_asset_id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(ModelProperties, self).__init__(**kwargs) + self.id = kwargs["id"] + self.name = kwargs["name"] + self.model_framework = kwargs["model_framework"] + self.model_framework_version = kwargs["model_framework_version"] + self.model_format = kwargs["model_format"] + self.version = kwargs["version"] + self.alphanumeric_version = kwargs["alphanumeric_version"] + self.url = kwargs["url"] + self.mime_type = kwargs["mime_type"] + self.modified_time = kwargs["modified_time"] + self.unpack = kwargs["unpack"] + self.parent_model_id = kwargs["parent_model_id"] + self.run_id = kwargs["run_id"] + self.experiment_name = kwargs["experiment_name"] + self.experiment_id = kwargs["experiment_id"] + self.derived_model_ids = kwargs["derived_model_ids"] + self.user_properties = kwargs["user_properties"] + self.is_anonymous = kwargs["is_anonymous"] + self.orgin_asset_id = kwargs["orgin_asset_id"] + self.creation_context = kwargs["creation_context"] + + +class ModelsVersionedEntitiesResponse(msrest.serialization.Model): + """ModelsVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.ModelsVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[ModelsVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.ModelsVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(ModelsVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class ModelsVersionedEntity(msrest.serialization.Model): + """ModelsVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.ModelsVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.ModelAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.ModelProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "ModelAnnotations"}, + "properties": {"key": "properties", "type": "ModelProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.ModelsVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.ModelAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.ModelProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(ModelsVersionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class ModuleAnnotations(msrest.serialization.Model): + """ModuleAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar module_name: Required. + :vartype module_name: str + :ivar display_name: Required. + :vartype display_name: str + :ivar lower_name: Required. + :vartype lower_name: str + :ivar module_version: Required. + :vartype module_version: str + :ivar inputs: Required. + :vartype inputs: list[~index_service_apis.models.InputNameAndDataTypeIdsList] + :ivar outputs: Required. + :vartype outputs: list[~index_service_apis.models.OutputNameAndDataTypeId] + :ivar category: Required. + :vartype category: str + :ivar step_type: Required. + :vartype step_type: str + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.ModuleAnnotationsEntityStatus + :ivar is_deterministic: Required. + :vartype is_deterministic: bool + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar last_updated_by: Required. + :vartype last_updated_by: ~index_service_apis.models.CreatedBy + :ivar component_type_version: Required. + :vartype component_type_version: str + :ivar snapshot_id: Required. + :vartype snapshot_id: str + :ivar runconfig: Required. + :vartype runconfig: str + :ivar control_outputs: Required. + :vartype control_outputs: list[~index_service_apis.models.ControlOutput] + :ivar parameters: Required. + :vartype parameters: list[~index_service_apis.models.StructuredInterfaceParameter] + :ivar metadata_parameters: Required. + :vartype metadata_parameters: list[~index_service_apis.models.StructuredInterfaceParameter] + :ivar aml_module_name: Required. + :vartype aml_module_name: str + :ivar aml_module_entity_status: Required. Possible values include: "Active", "Deprecated", + "Disabled". + :vartype aml_module_entity_status: str or + ~index_service_apis.models.ModuleAnnotationsAmlModuleEntityStatus + :ivar module_type: Required. Possible values include: "User", "Builtin". + :vartype module_type: str or ~index_service_apis.models.ModuleAnnotationsModuleType + :ivar module_execution_type: Required. + :vartype module_execution_type: str + :ivar arguments_serialized: Required. + :vartype arguments_serialized: str + :ivar cloud_settings_serialized: Required. + :vartype cloud_settings_serialized: str + :ivar stage: Required. + :vartype stage: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "module_name": {"required": True}, + "display_name": {"required": True}, + "lower_name": {"required": True}, + "module_version": {"required": True}, + "inputs": {"required": True}, + "outputs": {"required": True}, + "category": {"required": True}, + "step_type": {"required": True}, + "entity_status": {"required": True}, + "is_deterministic": {"required": True}, + "kv_tags": {"required": True}, + "properties": {"required": True}, + "last_modified_date": {"required": True}, + "last_updated_by": {"required": True}, + "component_type_version": {"required": True}, + "snapshot_id": {"required": True}, + "runconfig": {"required": True}, + "control_outputs": {"required": True}, + "parameters": {"required": True}, + "metadata_parameters": {"required": True}, + "aml_module_name": {"required": True}, + "aml_module_entity_status": {"required": True}, + "module_type": {"required": True}, + "module_execution_type": {"required": True}, + "arguments_serialized": {"required": True}, + "cloud_settings_serialized": {"required": True}, + "stage": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "module_name": {"key": "moduleName", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "lower_name": {"key": "lowerName", "type": "str"}, + "module_version": {"key": "moduleVersion", "type": "str"}, + "inputs": {"key": "inputs", "type": "[InputNameAndDataTypeIdsList]"}, + "outputs": {"key": "outputs", "type": "[OutputNameAndDataTypeId]"}, + "category": {"key": "category", "type": "str"}, + "step_type": {"key": "stepType", "type": "str"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "is_deterministic": {"key": "isDeterministic", "type": "bool"}, + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"}, + "component_type_version": {"key": "componentTypeVersion", "type": "str"}, + "snapshot_id": {"key": "snapshotId", "type": "str"}, + "runconfig": {"key": "runconfig", "type": "str"}, + "control_outputs": {"key": "controlOutputs", "type": "[ControlOutput]"}, + "parameters": {"key": "parameters", "type": "[StructuredInterfaceParameter]"}, + "metadata_parameters": {"key": "metadataParameters", "type": "[StructuredInterfaceParameter]"}, + "aml_module_name": {"key": "amlModuleName", "type": "str"}, + "aml_module_entity_status": {"key": "amlModuleEntityStatus", "type": "str"}, + "module_type": {"key": "moduleType", "type": "str"}, + "module_execution_type": {"key": "moduleExecutionType", "type": "str"}, + "arguments_serialized": {"key": "argumentsSerialized", "type": "str"}, + "cloud_settings_serialized": {"key": "cloudSettingsSerialized", "type": "str"}, + "stage": {"key": "stage", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword module_name: Required. + :paramtype module_name: str + :keyword display_name: Required. + :paramtype display_name: str + :keyword lower_name: Required. + :paramtype lower_name: str + :keyword module_version: Required. + :paramtype module_version: str + :keyword inputs: Required. + :paramtype inputs: list[~index_service_apis.models.InputNameAndDataTypeIdsList] + :keyword outputs: Required. + :paramtype outputs: list[~index_service_apis.models.OutputNameAndDataTypeId] + :keyword category: Required. + :paramtype category: str + :keyword step_type: Required. + :paramtype step_type: str + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or ~index_service_apis.models.ModuleAnnotationsEntityStatus + :keyword is_deterministic: Required. + :paramtype is_deterministic: bool + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword last_updated_by: Required. + :paramtype last_updated_by: ~index_service_apis.models.CreatedBy + :keyword component_type_version: Required. + :paramtype component_type_version: str + :keyword snapshot_id: Required. + :paramtype snapshot_id: str + :keyword runconfig: Required. + :paramtype runconfig: str + :keyword control_outputs: Required. + :paramtype control_outputs: list[~index_service_apis.models.ControlOutput] + :keyword parameters: Required. + :paramtype parameters: list[~index_service_apis.models.StructuredInterfaceParameter] + :keyword metadata_parameters: Required. + :paramtype metadata_parameters: list[~index_service_apis.models.StructuredInterfaceParameter] + :keyword aml_module_name: Required. + :paramtype aml_module_name: str + :keyword aml_module_entity_status: Required. Possible values include: "Active", "Deprecated", + "Disabled". + :paramtype aml_module_entity_status: str or + ~index_service_apis.models.ModuleAnnotationsAmlModuleEntityStatus + :keyword module_type: Required. Possible values include: "User", "Builtin". + :paramtype module_type: str or ~index_service_apis.models.ModuleAnnotationsModuleType + :keyword module_execution_type: Required. + :paramtype module_execution_type: str + :keyword arguments_serialized: Required. + :paramtype arguments_serialized: str + :keyword cloud_settings_serialized: Required. + :paramtype cloud_settings_serialized: str + :keyword stage: Required. + :paramtype stage: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(ModuleAnnotations, self).__init__(**kwargs) + self.module_name = kwargs["module_name"] + self.display_name = kwargs["display_name"] + self.lower_name = kwargs["lower_name"] + self.module_version = kwargs["module_version"] + self.inputs = kwargs["inputs"] + self.outputs = kwargs["outputs"] + self.category = kwargs["category"] + self.step_type = kwargs["step_type"] + self.entity_status = kwargs["entity_status"] + self.is_deterministic = kwargs["is_deterministic"] + self.kv_tags = kwargs["kv_tags"] + self.properties = kwargs["properties"] + self.last_modified_date = kwargs["last_modified_date"] + self.last_updated_by = kwargs["last_updated_by"] + self.component_type_version = kwargs["component_type_version"] + self.snapshot_id = kwargs["snapshot_id"] + self.runconfig = kwargs["runconfig"] + self.control_outputs = kwargs["control_outputs"] + self.parameters = kwargs["parameters"] + self.metadata_parameters = kwargs["metadata_parameters"] + self.aml_module_name = kwargs["aml_module_name"] + self.aml_module_entity_status = kwargs["aml_module_entity_status"] + self.module_type = kwargs["module_type"] + self.module_execution_type = kwargs["module_execution_type"] + self.arguments_serialized = kwargs["arguments_serialized"] + self.cloud_settings_serialized = kwargs["cloud_settings_serialized"] + self.stage = kwargs["stage"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class ModuleProperties(msrest.serialization.Model): + """ModuleProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar aml_module_id: Required. + :vartype aml_module_id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "aml_module_id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "aml_module_id": {"key": "amlModuleId", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword aml_module_id: Required. + :paramtype aml_module_id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(ModuleProperties, self).__init__(**kwargs) + self.id = kwargs["id"] + self.aml_module_id = kwargs["aml_module_id"] + self.creation_context = kwargs["creation_context"] + + +class ModulesVersionedEntitiesResponse(msrest.serialization.Model): + """ModulesVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.ModulesVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[ModulesVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.ModulesVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(ModulesVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class ModulesVersionedEntity(msrest.serialization.Model): + """ModulesVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.ModulesVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.ModuleAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.ModuleProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "ModuleAnnotations"}, + "properties": {"key": "properties", "type": "ModuleProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.ModulesVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.ModuleAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.ModuleProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(ModulesVersionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class NotificationSetting(msrest.serialization.Model): + """NotificationSetting. + + All required parameters must be populated in order to send to Azure. + + :ivar emails: Required. + :vartype emails: list[str] + :ivar email_on: Required. + :vartype email_on: list[str or ~index_service_apis.models.NotificationSettingEmailOnItem] + :ivar webhooks: Required. Dictionary of :code:`<Webhook>`. + :vartype webhooks: dict[str, ~index_service_apis.models.Webhook] + """ + + _validation = { + "emails": {"required": True}, + "email_on": {"required": True}, + "webhooks": {"required": True}, + } + + _attribute_map = { + "emails": {"key": "emails", "type": "[str]"}, + "email_on": {"key": "emailOn", "type": "[str]"}, + "webhooks": {"key": "webhooks", "type": "{Webhook}"}, + } + + def __init__(self, **kwargs): + """ + :keyword emails: Required. + :paramtype emails: list[str] + :keyword email_on: Required. + :paramtype email_on: list[str or ~index_service_apis.models.NotificationSettingEmailOnItem] + :keyword webhooks: Required. Dictionary of :code:`<Webhook>`. + :paramtype webhooks: dict[str, ~index_service_apis.models.Webhook] + """ + super(NotificationSetting, self).__init__(**kwargs) + self.emails = kwargs["emails"] + self.email_on = kwargs["email_on"] + self.webhooks = kwargs["webhooks"] + + +class OnlineEndpointAnnotations(msrest.serialization.Model): + """OnlineEndpointAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar compute_type: Required. + :vartype compute_type: str + :ivar compute_target: Required. + :vartype compute_target: ~index_service_apis.models.EndpointComputeTarget + :ivar scoring_uri: Required. + :vartype scoring_uri: str + :ivar location: Required. + :vartype location: str + :ivar last_modified_time: Required. + :vartype last_modified_time: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "compute_type": {"required": True}, + "compute_target": {"required": True}, + "scoring_uri": {"required": True}, + "location": {"required": True}, + "last_modified_time": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "compute_type": {"key": "computeType", "type": "str"}, + "compute_target": {"key": "computeTarget", "type": "EndpointComputeTarget"}, + "scoring_uri": {"key": "scoringUri", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword compute_type: Required. + :paramtype compute_type: str + :keyword compute_target: Required. + :paramtype compute_target: ~index_service_apis.models.EndpointComputeTarget + :keyword scoring_uri: Required. + :paramtype scoring_uri: str + :keyword location: Required. + :paramtype location: str + :keyword last_modified_time: Required. + :paramtype last_modified_time: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(OnlineEndpointAnnotations, self).__init__(**kwargs) + self.compute_type = kwargs["compute_type"] + self.compute_target = kwargs["compute_target"] + self.scoring_uri = kwargs["scoring_uri"] + self.location = kwargs["location"] + self.last_modified_time = kwargs["last_modified_time"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class OnlineEndpointProperties(msrest.serialization.Model): + """OnlineEndpointProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "properties": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "properties": {"key": "properties", "type": "{str}"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(OnlineEndpointProperties, self).__init__(**kwargs) + self.properties = kwargs["properties"] + self.creation_context = kwargs["creation_context"] + + +class OnlineendpointsUnversionedEntitiesResponse(msrest.serialization.Model): + """OnlineendpointsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.OnlineendpointsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[OnlineendpointsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.OnlineendpointsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(OnlineendpointsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class OnlineendpointsUnversionedEntity(msrest.serialization.Model): + """OnlineendpointsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.OnlineendpointsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.OnlineEndpointAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.OnlineEndpointProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "OnlineEndpointAnnotations"}, + "properties": {"key": "properties", "type": "OnlineEndpointProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.OnlineendpointsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.OnlineEndpointAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.OnlineEndpointProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(OnlineendpointsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class OutputNameAndDataTypeId(msrest.serialization.Model): + """OutputNameAndDataTypeId. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar data_type_id: Required. + :vartype data_type_id: str + :ivar description: Required. + :vartype description: str + :ivar label: Required. + :vartype label: str + """ + + _validation = { + "name": {"required": True}, + "data_type_id": {"required": True}, + "description": {"required": True}, + "label": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "data_type_id": {"key": "dataTypeId", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "label": {"key": "label", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword data_type_id: Required. + :paramtype data_type_id: str + :keyword description: Required. + :paramtype description: str + :keyword label: Required. + :paramtype label: str + """ + super(OutputNameAndDataTypeId, self).__init__(**kwargs) + self.name = kwargs["name"] + self.data_type_id = kwargs["data_type_id"] + self.description = kwargs["description"] + self.label = kwargs["label"] + + +class PipelineAnnotations(msrest.serialization.Model): + """PipelineAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar pipeline_name: Required. + :vartype pipeline_name: str + :ivar version: Required. + :vartype version: str + :ivar url: Required. + :vartype url: str + :ivar pipeline_endpoint_ids: Required. + :vartype pipeline_endpoint_ids: list[str] + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar step_tags: Required. Dictionary of :code:`<string>`. + :vartype step_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar step_properties: Required. Dictionary of :code:`<string>`. + :vartype step_properties: dict[str, str] + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.PipelineAnnotationsEntityStatus + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar last_updated_by: Required. + :vartype last_updated_by: ~index_service_apis.models.CreatedBy + :ivar last_run_id: Required. + :vartype last_run_id: str + :ivar pipeline_type: Required. + :vartype pipeline_type: str + :ivar last_run_status_code: Required. Possible values include: "NotStarted", "Running", + "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested". + :vartype last_run_status_code: str or + ~index_service_apis.models.PipelineAnnotationsLastRunStatusCode + :ivar last_run_creation_time: Required. + :vartype last_run_creation_time: ~datetime.datetime + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "pipeline_name": {"required": True}, + "version": {"required": True}, + "url": {"required": True}, + "pipeline_endpoint_ids": {"required": True}, + "kv_tags": {"required": True}, + "step_tags": {"required": True}, + "properties": {"required": True}, + "step_properties": {"required": True}, + "entity_status": {"required": True}, + "last_modified_date": {"required": True}, + "last_updated_by": {"required": True}, + "last_run_id": {"required": True}, + "pipeline_type": {"required": True}, + "last_run_status_code": {"required": True}, + "last_run_creation_time": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "pipeline_name": {"key": "pipelineName", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "url": {"key": "url", "type": "str"}, + "pipeline_endpoint_ids": {"key": "pipelineEndpointIds", "type": "[str]"}, + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "step_tags": {"key": "stepTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "step_properties": {"key": "stepProperties", "type": "{str}"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"}, + "last_run_id": {"key": "lastRunId", "type": "str"}, + "pipeline_type": {"key": "pipelineType", "type": "str"}, + "last_run_status_code": {"key": "lastRunStatusCode", "type": "str"}, + "last_run_creation_time": {"key": "lastRunCreationTime", "type": "iso-8601"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword pipeline_name: Required. + :paramtype pipeline_name: str + :keyword version: Required. + :paramtype version: str + :keyword url: Required. + :paramtype url: str + :keyword pipeline_endpoint_ids: Required. + :paramtype pipeline_endpoint_ids: list[str] + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword step_tags: Required. Dictionary of :code:`<string>`. + :paramtype step_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword step_properties: Required. Dictionary of :code:`<string>`. + :paramtype step_properties: dict[str, str] + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or ~index_service_apis.models.PipelineAnnotationsEntityStatus + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword last_updated_by: Required. + :paramtype last_updated_by: ~index_service_apis.models.CreatedBy + :keyword last_run_id: Required. + :paramtype last_run_id: str + :keyword pipeline_type: Required. + :paramtype pipeline_type: str + :keyword last_run_status_code: Required. Possible values include: "NotStarted", "Running", + "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested". + :paramtype last_run_status_code: str or + ~index_service_apis.models.PipelineAnnotationsLastRunStatusCode + :keyword last_run_creation_time: Required. + :paramtype last_run_creation_time: ~datetime.datetime + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(PipelineAnnotations, self).__init__(**kwargs) + self.pipeline_name = kwargs["pipeline_name"] + self.version = kwargs["version"] + self.url = kwargs["url"] + self.pipeline_endpoint_ids = kwargs["pipeline_endpoint_ids"] + self.kv_tags = kwargs["kv_tags"] + self.step_tags = kwargs["step_tags"] + self.properties = kwargs["properties"] + self.step_properties = kwargs["step_properties"] + self.entity_status = kwargs["entity_status"] + self.last_modified_date = kwargs["last_modified_date"] + self.last_updated_by = kwargs["last_updated_by"] + self.last_run_id = kwargs["last_run_id"] + self.pipeline_type = kwargs["pipeline_type"] + self.last_run_status_code = kwargs["last_run_status_code"] + self.last_run_creation_time = kwargs["last_run_creation_time"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class PipelineDraftAnnotations(msrest.serialization.Model): + """PipelineDraftAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar step_tags: Required. Dictionary of :code:`<string>`. + :vartype step_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar step_properties: Required. Dictionary of :code:`<string>`. + :vartype step_properties: dict[str, str] + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.PipelineDraftAnnotationsEntityStatus + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar pipeline_type: Required. + :vartype pipeline_type: str + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "kv_tags": {"required": True}, + "step_tags": {"required": True}, + "properties": {"required": True}, + "step_properties": {"required": True}, + "entity_status": {"required": True}, + "last_modified_date": {"required": True}, + "pipeline_type": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "step_tags": {"key": "stepTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "step_properties": {"key": "stepProperties", "type": "{str}"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "pipeline_type": {"key": "pipelineType", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword step_tags: Required. Dictionary of :code:`<string>`. + :paramtype step_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword step_properties: Required. Dictionary of :code:`<string>`. + :paramtype step_properties: dict[str, str] + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or + ~index_service_apis.models.PipelineDraftAnnotationsEntityStatus + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword pipeline_type: Required. + :paramtype pipeline_type: str + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(PipelineDraftAnnotations, self).__init__(**kwargs) + self.kv_tags = kwargs["kv_tags"] + self.step_tags = kwargs["step_tags"] + self.properties = kwargs["properties"] + self.step_properties = kwargs["step_properties"] + self.entity_status = kwargs["entity_status"] + self.last_modified_date = kwargs["last_modified_date"] + self.pipeline_type = kwargs["pipeline_type"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class PipelineDraftProperties(msrest.serialization.Model): + """PipelineDraftProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(PipelineDraftProperties, self).__init__(**kwargs) + self.id = kwargs["id"] + self.creation_context = kwargs["creation_context"] + + +class PipelinedraftsUnversionedEntitiesResponse(msrest.serialization.Model): + """PipelinedraftsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.PipelinedraftsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[PipelinedraftsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.PipelinedraftsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(PipelinedraftsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class PipelinedraftsUnversionedEntity(msrest.serialization.Model): + """PipelinedraftsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.PipelinedraftsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.PipelineDraftAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.PipelineDraftProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "PipelineDraftAnnotations"}, + "properties": {"key": "properties", "type": "PipelineDraftProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.PipelinedraftsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.PipelineDraftAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.PipelineDraftProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(PipelinedraftsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class PipelineProperties(msrest.serialization.Model): + """PipelineProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(PipelineProperties, self).__init__(**kwargs) + self.id = kwargs["id"] + self.creation_context = kwargs["creation_context"] + + +class PipelineRunAnnotations(msrest.serialization.Model): + """PipelineRunAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar step_tags: Required. Dictionary of :code:`<string>`. + :vartype step_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar step_properties: Required. Dictionary of :code:`<string>`. + :vartype step_properties: dict[str, str] + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.PipelineRunAnnotationsEntityStatus + :ivar status: Required. + :vartype status: ~index_service_apis.models.ExperimentStatus + :ivar run_history_experiment_name: Required. + :vartype run_history_experiment_name: str + :ivar has_errors: Required. + :vartype has_errors: bool + :ivar has_warnings: Required. + :vartype has_warnings: bool + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "kv_tags": {"required": True}, + "step_tags": {"required": True}, + "properties": {"required": True}, + "step_properties": {"required": True}, + "entity_status": {"required": True}, + "status": {"required": True}, + "run_history_experiment_name": {"required": True}, + "has_errors": {"required": True}, + "has_warnings": {"required": True}, + "last_modified_date": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "step_tags": {"key": "stepTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "step_properties": {"key": "stepProperties", "type": "{str}"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "status": {"key": "status", "type": "ExperimentStatus"}, + "run_history_experiment_name": {"key": "runHistoryExperimentName", "type": "str"}, + "has_errors": {"key": "hasErrors", "type": "bool"}, + "has_warnings": {"key": "hasWarnings", "type": "bool"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword step_tags: Required. Dictionary of :code:`<string>`. + :paramtype step_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword step_properties: Required. Dictionary of :code:`<string>`. + :paramtype step_properties: dict[str, str] + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or ~index_service_apis.models.PipelineRunAnnotationsEntityStatus + :keyword status: Required. + :paramtype status: ~index_service_apis.models.ExperimentStatus + :keyword run_history_experiment_name: Required. + :paramtype run_history_experiment_name: str + :keyword has_errors: Required. + :paramtype has_errors: bool + :keyword has_warnings: Required. + :paramtype has_warnings: bool + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(PipelineRunAnnotations, self).__init__(**kwargs) + self.kv_tags = kwargs["kv_tags"] + self.step_tags = kwargs["step_tags"] + self.properties = kwargs["properties"] + self.step_properties = kwargs["step_properties"] + self.entity_status = kwargs["entity_status"] + self.status = kwargs["status"] + self.run_history_experiment_name = kwargs["run_history_experiment_name"] + self.has_errors = kwargs["has_errors"] + self.has_warnings = kwargs["has_warnings"] + self.last_modified_date = kwargs["last_modified_date"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class PipelineRunProperties(msrest.serialization.Model): + """PipelineRunProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(PipelineRunProperties, self).__init__(**kwargs) + self.id = kwargs["id"] + self.creation_context = kwargs["creation_context"] + + +class PipelinerunsUnversionedEntitiesResponse(msrest.serialization.Model): + """PipelinerunsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.PipelinerunsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[PipelinerunsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.PipelinerunsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(PipelinerunsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class PipelinerunsUnversionedEntity(msrest.serialization.Model): + """PipelinerunsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.PipelinerunsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.PipelineRunAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.PipelineRunProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "PipelineRunAnnotations"}, + "properties": {"key": "properties", "type": "PipelineRunProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.PipelinerunsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.PipelineRunAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.PipelineRunProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + """ + super(PipelinerunsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.relationships = kwargs["relationships"] + + +class PipelinesVersionedEntitiesResponse(msrest.serialization.Model): + """PipelinesVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.PipelinesVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[PipelinesVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.PipelinesVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(PipelinesVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class PipelinesVersionedEntity(msrest.serialization.Model): + """PipelinesVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.PipelinesVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.PipelineAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.PipelineProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "PipelineAnnotations"}, + "properties": {"key": "properties", "type": "PipelineProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.PipelinesVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.PipelineAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.PipelineProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(PipelinesVersionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class Purpose(msrest.serialization.Model): + """Purpose. + + All required parameters must be populated in order to send to Azure. + + :ivar has_inferencing_support: Required. + :vartype has_inferencing_support: bool + :ivar has_training_support: Required. + :vartype has_training_support: bool + """ + + _validation = { + "has_inferencing_support": {"required": True}, + "has_training_support": {"required": True}, + } + + _attribute_map = { + "has_inferencing_support": {"key": "hasInferencingSupport", "type": "bool"}, + "has_training_support": {"key": "hasTrainingSupport", "type": "bool"}, + } + + def __init__(self, **kwargs): + """ + :keyword has_inferencing_support: Required. + :paramtype has_inferencing_support: bool + :keyword has_training_support: Required. + :paramtype has_training_support: bool + """ + super(Purpose, self).__init__(**kwargs) + self.has_inferencing_support = kwargs["has_inferencing_support"] + self.has_training_support = kwargs["has_training_support"] + + +class Recurrence(msrest.serialization.Model): + """Recurrence. + + All required parameters must be populated in order to send to Azure. + + :ivar frequency: Required. Possible values include: "Month", "Week", "Day", "Hour", "Minute". + :vartype frequency: str or ~index_service_apis.models.RecurrenceFrequency + :ivar interval: Required. + :vartype interval: int + :ivar schedule: Required. + :vartype schedule: ~index_service_apis.models.RecurrenceSchedule + :ivar end_time: Required. + :vartype end_time: str + :ivar start_time: Required. + :vartype start_time: str + :ivar time_zone: Required. + :vartype time_zone: str + """ + + _validation = { + "frequency": {"required": True}, + "interval": {"required": True}, + "schedule": {"required": True}, + "end_time": {"required": True}, + "start_time": {"required": True}, + "time_zone": {"required": True}, + } + + _attribute_map = { + "frequency": {"key": "frequency", "type": "str"}, + "interval": {"key": "interval", "type": "int"}, + "schedule": {"key": "schedule", "type": "RecurrenceSchedule"}, + "end_time": {"key": "endTime", "type": "str"}, + "start_time": {"key": "startTime", "type": "str"}, + "time_zone": {"key": "timeZone", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword frequency: Required. Possible values include: "Month", "Week", "Day", "Hour", + "Minute". + :paramtype frequency: str or ~index_service_apis.models.RecurrenceFrequency + :keyword interval: Required. + :paramtype interval: int + :keyword schedule: Required. + :paramtype schedule: ~index_service_apis.models.RecurrenceSchedule + :keyword end_time: Required. + :paramtype end_time: str + :keyword start_time: Required. + :paramtype start_time: str + :keyword time_zone: Required. + :paramtype time_zone: str + """ + super(Recurrence, self).__init__(**kwargs) + self.frequency = kwargs["frequency"] + self.interval = kwargs["interval"] + self.schedule = kwargs["schedule"] + self.end_time = kwargs["end_time"] + self.start_time = kwargs["start_time"] + self.time_zone = kwargs["time_zone"] + + +class RecurrenceSchedule(msrest.serialization.Model): + """RecurrenceSchedule. + + :ivar hours: + :vartype hours: list[int] + :ivar minutes: + :vartype minutes: list[int] + :ivar week_days: + :vartype week_days: list[str or ~index_service_apis.models.RecurrenceScheduleWeekDaysItem] + :ivar month_days: + :vartype month_days: list[int] + """ + + _attribute_map = { + "hours": {"key": "hours", "type": "[int]"}, + "minutes": {"key": "minutes", "type": "[int]"}, + "week_days": {"key": "weekDays", "type": "[str]"}, + "month_days": {"key": "monthDays", "type": "[int]"}, + } + + def __init__(self, **kwargs): + """ + :keyword hours: + :paramtype hours: list[int] + :keyword minutes: + :paramtype minutes: list[int] + :keyword week_days: + :paramtype week_days: list[str or ~index_service_apis.models.RecurrenceScheduleWeekDaysItem] + :keyword month_days: + :paramtype month_days: list[int] + """ + super(RecurrenceSchedule, self).__init__(**kwargs) + self.hours = kwargs.get("hours", None) + self.minutes = kwargs.get("minutes", None) + self.week_days = kwargs.get("week_days", None) + self.month_days = kwargs.get("month_days", None) + + +class RecurrenceTrigger(msrest.serialization.Model): + """RecurrenceTrigger. + + :ivar frequency: Possible values include: "Month", "Week", "Day", "Hour", "Minute". + :vartype frequency: str or ~index_service_apis.models.RecurrenceTriggerFrequency + :ivar interval: + :vartype interval: int + :ivar schedule: + :vartype schedule: ~index_service_apis.models.RecurrenceSchedule + """ + + _attribute_map = { + "frequency": {"key": "frequency", "type": "str"}, + "interval": {"key": "interval", "type": "int"}, + "schedule": {"key": "schedule", "type": "RecurrenceSchedule"}, + } + + def __init__(self, **kwargs): + """ + :keyword frequency: Possible values include: "Month", "Week", "Day", "Hour", "Minute". + :paramtype frequency: str or ~index_service_apis.models.RecurrenceTriggerFrequency + :keyword interval: + :paramtype interval: int + :keyword schedule: + :paramtype schedule: ~index_service_apis.models.RecurrenceSchedule + """ + super(RecurrenceTrigger, self).__init__(**kwargs) + self.frequency = kwargs.get("frequency", None) + self.interval = kwargs.get("interval", None) + self.schedule = kwargs.get("schedule", None) + + +class Relationship(msrest.serialization.Model): + """Relationship. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar relation_type: + :vartype relation_type: str + :ivar target_entity_id: + :vartype target_entity_id: str + :ivar asset_id: + :vartype asset_id: str + :ivar entity_type: + :vartype entity_type: str + :ivar direction: + :vartype direction: str + :ivar entity_container_id: + :vartype entity_container_id: str + """ + + _validation = { + "entity_type": {"readonly": True}, + "entity_container_id": {"readonly": True}, + } + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "relation_type": {"key": "relationType", "type": "str"}, + "target_entity_id": {"key": "targetEntityId", "type": "str"}, + "asset_id": {"key": "assetId", "type": "str"}, + "entity_type": {"key": "entityType", "type": "str"}, + "direction": {"key": "direction", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword relation_type: + :paramtype relation_type: str + :keyword target_entity_id: + :paramtype target_entity_id: str + :keyword asset_id: + :paramtype asset_id: str + :keyword direction: + :paramtype direction: str + """ + super(Relationship, self).__init__(**kwargs) + self.additional_properties = kwargs.get("additional_properties", None) + self.relation_type = kwargs.get("relation_type", None) + self.target_entity_id = kwargs.get("target_entity_id", None) + self.asset_id = kwargs.get("asset_id", None) + self.entity_type = None + self.direction = kwargs.get("direction", None) + self.entity_container_id = None + + +class ResourceDiscoveryContainerMetadata(msrest.serialization.Model): + """ResourceDiscoveryContainerMetadata. + + :ivar tags: A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + :ivar tenant_id: + :vartype tenant_id: str + :ivar resource_id: + :vartype resource_id: str + :ivar resource_arm_id: + :vartype resource_arm_id: str + :ivar subscription_id: + :vartype subscription_id: str + :ivar resource_group: + :vartype resource_group: str + :ivar resource_name: + :vartype resource_name: str + :ivar asset_container_type: + :vartype asset_container_type: str + :ivar immutable_resource_id: + :vartype immutable_resource_id: str + :ivar asset_resource_type: + :vartype asset_resource_type: str + :ivar is_customer_managed_resource: + :vartype is_customer_managed_resource: bool + :ivar is_private_link_behind_vnet: + :vartype is_private_link_behind_vnet: bool + :ivar is_public_container: + :vartype is_public_container: bool + :ivar is_public_resource: + :vartype is_public_resource: bool + :ivar regions: + :vartype regions: list[~index_service_apis.models.ResourceRegion] + """ + + _attribute_map = { + "tags": {"key": "tags", "type": "{str}"}, + "tenant_id": {"key": "tenantId", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + "resource_arm_id": {"key": "resourceArmId", "type": "str"}, + "subscription_id": {"key": "subscriptionId", "type": "str"}, + "resource_group": {"key": "resourceGroup", "type": "str"}, + "resource_name": {"key": "resourceName", "type": "str"}, + "asset_container_type": {"key": "assetContainerType", "type": "str"}, + "immutable_resource_id": {"key": "immutableResourceId", "type": "str"}, + "asset_resource_type": {"key": "assetResourceType", "type": "str"}, + "is_customer_managed_resource": {"key": "isCustomerManagedResource", "type": "bool"}, + "is_private_link_behind_vnet": {"key": "isPrivateLinkBehindVnet", "type": "bool"}, + "is_public_container": {"key": "isPublicContainer", "type": "bool"}, + "is_public_resource": {"key": "isPublicResource", "type": "bool"}, + "regions": {"key": "regions", "type": "[ResourceRegion]"}, + } + + def __init__(self, **kwargs): + """ + :keyword tags: A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + :keyword tenant_id: + :paramtype tenant_id: str + :keyword resource_id: + :paramtype resource_id: str + :keyword resource_arm_id: + :paramtype resource_arm_id: str + :keyword subscription_id: + :paramtype subscription_id: str + :keyword resource_group: + :paramtype resource_group: str + :keyword resource_name: + :paramtype resource_name: str + :keyword asset_container_type: + :paramtype asset_container_type: str + :keyword immutable_resource_id: + :paramtype immutable_resource_id: str + :keyword asset_resource_type: + :paramtype asset_resource_type: str + :keyword is_customer_managed_resource: + :paramtype is_customer_managed_resource: bool + :keyword is_private_link_behind_vnet: + :paramtype is_private_link_behind_vnet: bool + :keyword is_public_container: + :paramtype is_public_container: bool + :keyword is_public_resource: + :paramtype is_public_resource: bool + :keyword regions: + :paramtype regions: list[~index_service_apis.models.ResourceRegion] + """ + super(ResourceDiscoveryContainerMetadata, self).__init__(**kwargs) + self.tags = kwargs.get("tags", None) + self.tenant_id = kwargs.get("tenant_id", None) + self.resource_id = kwargs.get("resource_id", None) + self.resource_arm_id = kwargs.get("resource_arm_id", None) + self.subscription_id = kwargs.get("subscription_id", None) + self.resource_group = kwargs.get("resource_group", None) + self.resource_name = kwargs.get("resource_name", None) + self.asset_container_type = kwargs.get("asset_container_type", None) + self.immutable_resource_id = kwargs.get("immutable_resource_id", None) + self.asset_resource_type = kwargs.get("asset_resource_type", None) + self.is_customer_managed_resource = kwargs.get("is_customer_managed_resource", None) + self.is_private_link_behind_vnet = kwargs.get("is_private_link_behind_vnet", None) + self.is_public_container = kwargs.get("is_public_container", None) + self.is_public_resource = kwargs.get("is_public_resource", None) + self.regions = kwargs.get("regions", None) + + +class ResourceDiscoveryContainerMetadataPaginatedResult(msrest.serialization.Model): + """ResourceDiscoveryContainerMetadataPaginatedResult. + + :ivar value: + :vartype value: list[~index_service_apis.models.ResourceDiscoveryContainerMetadata] + :ivar continuation_token: + :vartype continuation_token: str + :ivar next_link: + :vartype next_link: str + """ + + _attribute_map = { + "value": {"key": "value", "type": "[ResourceDiscoveryContainerMetadata]"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword value: + :paramtype value: list[~index_service_apis.models.ResourceDiscoveryContainerMetadata] + :keyword continuation_token: + :paramtype continuation_token: str + :keyword next_link: + :paramtype next_link: str + """ + super(ResourceDiscoveryContainerMetadataPaginatedResult, self).__init__(**kwargs) + self.value = kwargs.get("value", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.next_link = kwargs.get("next_link", None) + + +class ResourceDiscoveryRequest(msrest.serialization.Model): + """ResourceDiscoveryRequest. + + :ivar search_request: + :vartype search_request: ~index_service_apis.models.StringContainsRequest + :ivar order_by: + :vartype order_by: ~index_service_apis.models.IndexEntitiesRequestOrder + :ivar filters: + :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar page_size: + :vartype page_size: int + :ivar continuation_token: + :vartype continuation_token: str + """ + + _attribute_map = { + "search_request": {"key": "searchRequest", "type": "StringContainsRequest"}, + "order_by": {"key": "orderBy", "type": "IndexEntitiesRequestOrder"}, + "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"}, + "page_size": {"key": "pageSize", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword search_request: + :paramtype search_request: ~index_service_apis.models.StringContainsRequest + :keyword order_by: + :paramtype order_by: ~index_service_apis.models.IndexEntitiesRequestOrder + :keyword filters: + :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword page_size: + :paramtype page_size: int + :keyword continuation_token: + :paramtype continuation_token: str + """ + super(ResourceDiscoveryRequest, self).__init__(**kwargs) + self.search_request = kwargs.get("search_request", None) + self.order_by = kwargs.get("order_by", None) + self.filters = kwargs.get("filters", None) + self.page_size = kwargs.get("page_size", None) + self.continuation_token = kwargs.get("continuation_token", None) + + +class ResourceInformation(msrest.serialization.Model): + """ResourceInformation. + + :ivar region: + :vartype region: str + :ivar entity_container_type: Possible values include: "Workspace", "Feed", "Registry". + :vartype entity_container_type: str or ~index_service_apis.models.AssetContainerTypeFeedRename + :ivar resource_id: + :vartype resource_id: str + """ + + _attribute_map = { + "region": {"key": "region", "type": "str"}, + "entity_container_type": {"key": "entityContainerType", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword region: + :paramtype region: str + :keyword entity_container_type: Possible values include: "Workspace", "Feed", "Registry". + :paramtype entity_container_type: str or + ~index_service_apis.models.AssetContainerTypeFeedRename + :keyword resource_id: + :paramtype resource_id: str + """ + super(ResourceInformation, self).__init__(**kwargs) + self.region = kwargs.get("region", None) + self.entity_container_type = kwargs.get("entity_container_type", None) + self.resource_id = kwargs.get("resource_id", None) + + +class ResourceRegion(msrest.serialization.Model): + """ResourceRegion. + + :ivar region_name: + :vartype region_name: str + :ivar is_primary_region: + :vartype is_primary_region: bool + """ + + _attribute_map = { + "region_name": {"key": "regionName", "type": "str"}, + "is_primary_region": {"key": "isPrimaryRegion", "type": "bool"}, + } + + def __init__(self, **kwargs): + """ + :keyword region_name: + :paramtype region_name: str + :keyword is_primary_region: + :paramtype is_primary_region: bool + """ + super(ResourceRegion, self).__init__(**kwargs) + self.region_name = kwargs.get("region_name", None) + self.is_primary_region = kwargs.get("is_primary_region", None) + + +class RootError(msrest.serialization.Model): + """RootError. + + :ivar code: + :vartype code: str + :ivar severity: + :vartype severity: int + :ivar message: + :vartype message: str + :ivar message_format: + :vartype message_format: str + :ivar message_parameters: Dictionary of :code:`<string>`. + :vartype message_parameters: dict[str, str] + :ivar reference_code: + :vartype reference_code: str + :ivar details_uri: + :vartype details_uri: str + :ivar target: + :vartype target: str + :ivar details: + :vartype details: list[~index_service_apis.models.RootError] + :ivar inner_error: + :vartype inner_error: ~index_service_apis.models.InnerErrorResponse + :ivar debug_info: + :vartype debug_info: ~index_service_apis.models.DebugInfoResponse + :ivar additional_info: + :vartype additional_info: list[~index_service_apis.models.ErrorAdditionalInfo] + """ + + _attribute_map = { + "code": {"key": "code", "type": "str"}, + "severity": {"key": "severity", "type": "int"}, + "message": {"key": "message", "type": "str"}, + "message_format": {"key": "messageFormat", "type": "str"}, + "message_parameters": {"key": "messageParameters", "type": "{str}"}, + "reference_code": {"key": "referenceCode", "type": "str"}, + "details_uri": {"key": "detailsUri", "type": "str"}, + "target": {"key": "target", "type": "str"}, + "details": {"key": "details", "type": "[RootError]"}, + "inner_error": {"key": "innerError", "type": "InnerErrorResponse"}, + "debug_info": {"key": "debugInfo", "type": "DebugInfoResponse"}, + "additional_info": {"key": "additionalInfo", "type": "[ErrorAdditionalInfo]"}, + } + + def __init__(self, **kwargs): + """ + :keyword code: + :paramtype code: str + :keyword severity: + :paramtype severity: int + :keyword message: + :paramtype message: str + :keyword message_format: + :paramtype message_format: str + :keyword message_parameters: Dictionary of :code:`<string>`. + :paramtype message_parameters: dict[str, str] + :keyword reference_code: + :paramtype reference_code: str + :keyword details_uri: + :paramtype details_uri: str + :keyword target: + :paramtype target: str + :keyword details: + :paramtype details: list[~index_service_apis.models.RootError] + :keyword inner_error: + :paramtype inner_error: ~index_service_apis.models.InnerErrorResponse + :keyword debug_info: + :paramtype debug_info: ~index_service_apis.models.DebugInfoResponse + :keyword additional_info: + :paramtype additional_info: list[~index_service_apis.models.ErrorAdditionalInfo] + """ + super(RootError, self).__init__(**kwargs) + self.code = kwargs.get("code", None) + self.severity = kwargs.get("severity", None) + self.message = kwargs.get("message", None) + self.message_format = kwargs.get("message_format", None) + self.message_parameters = kwargs.get("message_parameters", None) + self.reference_code = kwargs.get("reference_code", None) + self.details_uri = kwargs.get("details_uri", None) + self.target = kwargs.get("target", None) + self.details = kwargs.get("details", None) + self.inner_error = kwargs.get("inner_error", None) + self.debug_info = kwargs.get("debug_info", None) + self.additional_info = kwargs.get("additional_info", None) + + +class RunAnnotations(msrest.serialization.Model): + """RunAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar display_name: Required. + :vartype display_name: str + :ivar status: Required. + :vartype status: str + :ivar primary_metric_name: Required. + :vartype primary_metric_name: str + :ivar estimated_cost: Required. + :vartype estimated_cost: float + :ivar primary_metric_summary: Required. + :vartype primary_metric_summary: ~index_service_apis.models.RunIndexMetricSummaryJValue + :ivar metrics: Required. Dictionary of <RunIndexMetricSummary:code:`<Object>`>. + :vartype metrics: dict[str, ~index_service_apis.models.RunIndexMetricSummaryObject] + :ivar parameters: Required. Dictionary of :code:`<AnyObject>`. + :vartype parameters: dict[str, any] + :ivar settings: Required. Dictionary of :code:`<string>`. + :vartype settings: dict[str, str] + :ivar modified_time: Required. + :vartype modified_time: ~datetime.datetime + :ivar retain_for_lifetime_of_workspace: Required. + :vartype retain_for_lifetime_of_workspace: bool + :ivar error: Required. + :vartype error: ~index_service_apis.models.IndexedErrorResponse + :ivar resource_metric_summary: Required. + :vartype resource_metric_summary: ~index_service_apis.models.RunIndexResourceMetricSummary + :ivar job_cost: Required. + :vartype job_cost: ~index_service_apis.models.JobCost + :ivar compute_duration: Required. + :vartype compute_duration: str + :ivar compute_duration_milliseconds: Required. + :vartype compute_duration_milliseconds: float + :ivar effective_start_time_utc: Required. + :vartype effective_start_time_utc: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "display_name": {"required": True}, + "status": {"required": True}, + "primary_metric_name": {"required": True}, + "estimated_cost": {"required": True}, + "primary_metric_summary": {"required": True}, + "metrics": {"required": True}, + "parameters": {"required": True}, + "settings": {"required": True}, + "modified_time": {"required": True}, + "retain_for_lifetime_of_workspace": {"required": True}, + "error": {"required": True}, + "resource_metric_summary": {"required": True}, + "job_cost": {"required": True}, + "compute_duration": {"required": True}, + "compute_duration_milliseconds": {"required": True}, + "effective_start_time_utc": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "display_name": {"key": "displayName", "type": "str"}, + "status": {"key": "status", "type": "str"}, + "primary_metric_name": {"key": "primaryMetricName", "type": "str"}, + "estimated_cost": {"key": "estimatedCost", "type": "float"}, + "primary_metric_summary": {"key": "primaryMetricSummary", "type": "RunIndexMetricSummaryJValue"}, + "metrics": {"key": "metrics", "type": "{RunIndexMetricSummaryObject}"}, + "parameters": {"key": "parameters", "type": "{object}"}, + "settings": {"key": "settings", "type": "{str}"}, + "modified_time": {"key": "modifiedTime", "type": "iso-8601"}, + "retain_for_lifetime_of_workspace": {"key": "retainForLifetimeOfWorkspace", "type": "bool"}, + "error": {"key": "error", "type": "IndexedErrorResponse"}, + "resource_metric_summary": {"key": "resourceMetricSummary", "type": "RunIndexResourceMetricSummary"}, + "job_cost": {"key": "jobCost", "type": "JobCost"}, + "compute_duration": {"key": "computeDuration", "type": "str"}, + "compute_duration_milliseconds": {"key": "computeDurationMilliseconds", "type": "float"}, + "effective_start_time_utc": {"key": "effectiveStartTimeUtc", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, **kwargs): + """ + :keyword display_name: Required. + :paramtype display_name: str + :keyword status: Required. + :paramtype status: str + :keyword primary_metric_name: Required. + :paramtype primary_metric_name: str + :keyword estimated_cost: Required. + :paramtype estimated_cost: float + :keyword primary_metric_summary: Required. + :paramtype primary_metric_summary: ~index_service_apis.models.RunIndexMetricSummaryJValue + :keyword metrics: Required. Dictionary of <RunIndexMetricSummary:code:`<Object>`>. + :paramtype metrics: dict[str, ~index_service_apis.models.RunIndexMetricSummaryObject] + :keyword parameters: Required. Dictionary of :code:`<AnyObject>`. + :paramtype parameters: dict[str, any] + :keyword settings: Required. Dictionary of :code:`<string>`. + :paramtype settings: dict[str, str] + :keyword modified_time: Required. + :paramtype modified_time: ~datetime.datetime + :keyword retain_for_lifetime_of_workspace: Required. + :paramtype retain_for_lifetime_of_workspace: bool + :keyword error: Required. + :paramtype error: ~index_service_apis.models.IndexedErrorResponse + :keyword resource_metric_summary: Required. + :paramtype resource_metric_summary: ~index_service_apis.models.RunIndexResourceMetricSummary + :keyword job_cost: Required. + :paramtype job_cost: ~index_service_apis.models.JobCost + :keyword compute_duration: Required. + :paramtype compute_duration: str + :keyword compute_duration_milliseconds: Required. + :paramtype compute_duration_milliseconds: float + :keyword effective_start_time_utc: Required. + :paramtype effective_start_time_utc: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(RunAnnotations, self).__init__(**kwargs) + self.display_name = kwargs["display_name"] + self.status = kwargs["status"] + self.primary_metric_name = kwargs["primary_metric_name"] + self.estimated_cost = kwargs["estimated_cost"] + self.primary_metric_summary = kwargs["primary_metric_summary"] + self.metrics = kwargs["metrics"] + self.parameters = kwargs["parameters"] + self.settings = kwargs["settings"] + self.modified_time = kwargs["modified_time"] + self.retain_for_lifetime_of_workspace = kwargs["retain_for_lifetime_of_workspace"] + self.error = kwargs["error"] + self.resource_metric_summary = kwargs["resource_metric_summary"] + self.job_cost = kwargs["job_cost"] + self.compute_duration = kwargs["compute_duration"] + self.compute_duration_milliseconds = kwargs["compute_duration_milliseconds"] + self.effective_start_time_utc = kwargs["effective_start_time_utc"] + self.name = kwargs["name"] + self.description = kwargs["description"] + self.archived = kwargs["archived"] + self.tags = kwargs["tags"] + + +class RunIndexMetricSummaryJValue(msrest.serialization.Model): + """RunIndexMetricSummaryJValue. + + All required parameters must be populated in order to send to Azure. + + :ivar count: Required. + :vartype count: int + :ivar last_value: Required. Any object. + :vartype last_value: any + :ivar minimum_value: Required. Any object. + :vartype minimum_value: any + :ivar maximum_value: Required. Any object. + :vartype maximum_value: any + :ivar metric_type: Required. + :vartype metric_type: str + """ + + _validation = { + "count": {"required": True}, + "last_value": {"required": True}, + "minimum_value": {"required": True}, + "maximum_value": {"required": True}, + "metric_type": {"required": True}, + } + + _attribute_map = { + "count": {"key": "count", "type": "int"}, + "last_value": {"key": "lastValue", "type": "object"}, + "minimum_value": {"key": "minimumValue", "type": "object"}, + "maximum_value": {"key": "maximumValue", "type": "object"}, + "metric_type": {"key": "metricType", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword count: Required. + :paramtype count: int + :keyword last_value: Required. Any object. + :paramtype last_value: any + :keyword minimum_value: Required. Any object. + :paramtype minimum_value: any + :keyword maximum_value: Required. Any object. + :paramtype maximum_value: any + :keyword metric_type: Required. + :paramtype metric_type: str + """ + super(RunIndexMetricSummaryJValue, self).__init__(**kwargs) + self.count = kwargs["count"] + self.last_value = kwargs["last_value"] + self.minimum_value = kwargs["minimum_value"] + self.maximum_value = kwargs["maximum_value"] + self.metric_type = kwargs["metric_type"] + + +class RunIndexMetricSummaryObject(msrest.serialization.Model): + """RunIndexMetricSummaryObject. + + All required parameters must be populated in order to send to Azure. + + :ivar count: Required. + :vartype count: int + :ivar last_value: Required. Anything. + :vartype last_value: any + :ivar minimum_value: Required. Anything. + :vartype minimum_value: any + :ivar maximum_value: Required. Anything. + :vartype maximum_value: any + :ivar metric_type: Required. + :vartype metric_type: str + """ + + _validation = { + "count": {"required": True}, + "last_value": {"required": True}, + "minimum_value": {"required": True}, + "maximum_value": {"required": True}, + "metric_type": {"required": True}, + } + + _attribute_map = { + "count": {"key": "count", "type": "int"}, + "last_value": {"key": "lastValue", "type": "object"}, + "minimum_value": {"key": "minimumValue", "type": "object"}, + "maximum_value": {"key": "maximumValue", "type": "object"}, + "metric_type": {"key": "metricType", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword count: Required. + :paramtype count: int + :keyword last_value: Required. Anything. + :paramtype last_value: any + :keyword minimum_value: Required. Anything. + :paramtype minimum_value: any + :keyword maximum_value: Required. Anything. + :paramtype maximum_value: any + :keyword metric_type: Required. + :paramtype metric_type: str + """ + super(RunIndexMetricSummaryObject, self).__init__(**kwargs) + self.count = kwargs["count"] + self.last_value = kwargs["last_value"] + self.minimum_value = kwargs["minimum_value"] + self.maximum_value = kwargs["maximum_value"] + self.metric_type = kwargs["metric_type"] + + +class RunIndexResourceMetricSummary(msrest.serialization.Model): + """RunIndexResourceMetricSummary. + + All required parameters must be populated in order to send to Azure. + + :ivar gpu_utilization_percent_last_hour: Required. + :vartype gpu_utilization_percent_last_hour: float + :ivar gpu_memory_utilization_percent_last_hour: Required. + :vartype gpu_memory_utilization_percent_last_hour: float + :ivar gpu_energy_joules: Required. + :vartype gpu_energy_joules: float + :ivar resource_metric_names: Required. + :vartype resource_metric_names: list[str] + """ + + _validation = { + "gpu_utilization_percent_last_hour": {"required": True}, + "gpu_memory_utilization_percent_last_hour": {"required": True}, + "gpu_energy_joules": {"required": True}, + "resource_metric_names": {"required": True}, + } + + _attribute_map = { + "gpu_utilization_percent_last_hour": {"key": "gpuUtilizationPercentLastHour", "type": "float"}, + "gpu_memory_utilization_percent_last_hour": {"key": "gpuMemoryUtilizationPercentLastHour", "type": "float"}, + "gpu_energy_joules": {"key": "gpuEnergyJoules", "type": "float"}, + "resource_metric_names": {"key": "resourceMetricNames", "type": "[str]"}, + } + + def __init__(self, **kwargs): + """ + :keyword gpu_utilization_percent_last_hour: Required. + :paramtype gpu_utilization_percent_last_hour: float + :keyword gpu_memory_utilization_percent_last_hour: Required. + :paramtype gpu_memory_utilization_percent_last_hour: float + :keyword gpu_energy_joules: Required. + :paramtype gpu_energy_joules: float + :keyword resource_metric_names: Required. + :paramtype resource_metric_names: list[str] + """ + super(RunIndexResourceMetricSummary, self).__init__(**kwargs) + self.gpu_utilization_percent_last_hour = kwargs["gpu_utilization_percent_last_hour"] + self.gpu_memory_utilization_percent_last_hour = kwargs["gpu_memory_utilization_percent_last_hour"] + self.gpu_energy_joules = kwargs["gpu_energy_joules"] + self.resource_metric_names = kwargs["resource_metric_names"] + + +class RunProperties(msrest.serialization.Model): + """RunProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar data_container_id: Required. + :vartype data_container_id: str + :ivar target_name: Required. + :vartype target_name: str + :ivar run_name: Required. + :vartype run_name: str + :ivar experiment_name: Required. + :vartype experiment_name: str + :ivar run_id: Required. + :vartype run_id: str + :ivar parent_run_id: Required. + :vartype parent_run_id: str + :ivar root_run_id: Required. + :vartype root_run_id: str + :ivar run_type: Required. + :vartype run_type: str + :ivar run_type_v2: Required. + :vartype run_type_v2: ~index_service_apis.models.RunTypeV2Index + :ivar script_name: Required. + :vartype script_name: str + :ivar experiment_id: Required. + :vartype experiment_id: str + :ivar run_uuid: Required. + :vartype run_uuid: str + :ivar parent_run_uuid: Required. + :vartype parent_run_uuid: str + :ivar run_number: Required. + :vartype run_number: int + :ivar start_time: Required. + :vartype start_time: ~datetime.datetime + :ivar end_time: Required. + :vartype end_time: ~datetime.datetime + :ivar compute_request: Required. + :vartype compute_request: ~index_service_apis.models.ComputeRequest + :ivar compute: Required. + :vartype compute: ~index_service_apis.models.Compute + :ivar user_properties: Required. Dictionary of :code:`<string>`. + :vartype user_properties: dict[str, str] + :ivar action_uris: Required. Dictionary of :code:`<string>`. + :vartype action_uris: dict[str, str] + :ivar duration: Required. + :vartype duration: str + :ivar duration_milliseconds: Required. + :vartype duration_milliseconds: float + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "data_container_id": {"required": True}, + "target_name": {"required": True}, + "run_name": {"required": True}, + "experiment_name": {"required": True}, + "run_id": {"required": True}, + "parent_run_id": {"required": True}, + "root_run_id": {"required": True}, + "run_type": {"required": True}, + "run_type_v2": {"required": True}, + "script_name": {"required": True}, + "experiment_id": {"required": True}, + "run_uuid": {"required": True}, + "parent_run_uuid": {"required": True}, + "run_number": {"required": True}, + "start_time": {"required": True}, + "end_time": {"required": True}, + "compute_request": {"required": True}, + "compute": {"required": True}, + "user_properties": {"required": True}, + "action_uris": {"required": True}, + "duration": {"required": True}, + "duration_milliseconds": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "data_container_id": {"key": "dataContainerId", "type": "str"}, + "target_name": {"key": "targetName", "type": "str"}, + "run_name": {"key": "runName", "type": "str"}, + "experiment_name": {"key": "experimentName", "type": "str"}, + "run_id": {"key": "runId", "type": "str"}, + "parent_run_id": {"key": "parentRunId", "type": "str"}, + "root_run_id": {"key": "rootRunId", "type": "str"}, + "run_type": {"key": "runType", "type": "str"}, + "run_type_v2": {"key": "runTypeV2", "type": "RunTypeV2Index"}, + "script_name": {"key": "scriptName", "type": "str"}, + "experiment_id": {"key": "experimentId", "type": "str"}, + "run_uuid": {"key": "runUuid", "type": "str"}, + "parent_run_uuid": {"key": "parentRunUuid", "type": "str"}, + "run_number": {"key": "runNumber", "type": "int"}, + "start_time": {"key": "startTime", "type": "iso-8601"}, + "end_time": {"key": "endTime", "type": "iso-8601"}, + "compute_request": {"key": "computeRequest", "type": "ComputeRequest"}, + "compute": {"key": "compute", "type": "Compute"}, + "user_properties": {"key": "userProperties", "type": "{str}"}, + "action_uris": {"key": "actionUris", "type": "{str}"}, + "duration": {"key": "duration", "type": "str"}, + "duration_milliseconds": {"key": "durationMilliseconds", "type": "float"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, **kwargs): + """ + :keyword data_container_id: Required. + :paramtype data_container_id: str + :keyword target_name: Required. + :paramtype target_name: str + :keyword run_name: Required. + :paramtype run_name: str + :keyword experiment_name: Required. + :paramtype experiment_name: str + :keyword run_id: Required. + :paramtype run_id: str + :keyword parent_run_id: Required. + :paramtype parent_run_id: str + :keyword root_run_id: Required. + :paramtype root_run_id: str + :keyword run_type: Required. + :paramtype run_type: str + :keyword run_type_v2: Required. + :paramtype run_type_v2: ~index_service_apis.models.RunTypeV2Index + :keyword script_name: Required. + :paramtype script_name: str + :keyword experiment_id: Required. + :paramtype experiment_id: str + :keyword run_uuid: Required. + :paramtype run_uuid: str + :keyword parent_run_uuid: Required. + :paramtype parent_run_uuid: str + :keyword run_number: Required. + :paramtype run_number: int + :keyword start_time: Required. + :paramtype start_time: ~datetime.datetime + :keyword end_time: Required. + :paramtype end_time: ~datetime.datetime + :keyword compute_request: Required. + :paramtype compute_request: ~index_service_apis.models.ComputeRequest + :keyword compute: Required. + :paramtype compute: ~index_service_apis.models.Compute + :keyword user_properties: Required. Dictionary of :code:`<string>`. + :paramtype user_properties: dict[str, str] + :keyword action_uris: Required. Dictionary of :code:`<string>`. + :paramtype action_uris: dict[str, str] + :keyword duration: Required. + :paramtype duration: str + :keyword duration_milliseconds: Required. + :paramtype duration_milliseconds: float + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(RunProperties, self).__init__(**kwargs) + self.data_container_id = kwargs["data_container_id"] + self.target_name = kwargs["target_name"] + self.run_name = kwargs["run_name"] + self.experiment_name = kwargs["experiment_name"] + self.run_id = kwargs["run_id"] + self.parent_run_id = kwargs["parent_run_id"] + self.root_run_id = kwargs["root_run_id"] + self.run_type = kwargs["run_type"] + self.run_type_v2 = kwargs["run_type_v2"] + self.script_name = kwargs["script_name"] + self.experiment_id = kwargs["experiment_id"] + self.run_uuid = kwargs["run_uuid"] + self.parent_run_uuid = kwargs["parent_run_uuid"] + self.run_number = kwargs["run_number"] + self.start_time = kwargs["start_time"] + self.end_time = kwargs["end_time"] + self.compute_request = kwargs["compute_request"] + self.compute = kwargs["compute"] + self.user_properties = kwargs["user_properties"] + self.action_uris = kwargs["action_uris"] + self.duration = kwargs["duration"] + self.duration_milliseconds = kwargs["duration_milliseconds"] + self.creation_context = kwargs["creation_context"] + + +class RunsUnversionedEntitiesResponse(msrest.serialization.Model): + """RunsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.RunsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[RunsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.RunsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(RunsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + self.value = kwargs.get("value", None) + self.next_skip = kwargs.get("next_skip", None) + self.continuation_token = kwargs.get("continuation_token", None) + self.entity_container_ids_to_entity_container_metadata = kwargs.get( + "entity_container_ids_to_entity_container_metadata", None + ) + self.number_of_entity_containers_not_queried = kwargs.get("number_of_entity_containers_not_queried", None) + self.fanout_data = kwargs.get("fanout_data", None) + self.shard_errors = kwargs.get("shard_errors", None) + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = kwargs.get( + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern", None + ) + + +class RunsUnversionedEntity(msrest.serialization.Model): + """RunsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.RunsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.RunAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.RunProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "RunAnnotations"}, + "properties": {"key": "properties", "type": "RunProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.RunsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.RunAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.RunProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(RunsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = kwargs["schema_id"] + self.entity_id = kwargs["entity_id"] + self.kind = kwargs["kind"] + self.annotations = kwargs["annotations"] + self.properties = kwargs["properties"] + self.internal = kwargs["internal"] + self.update_sequence = kwargs["update_sequence"] + self.type = kwargs["type"] + self.version = kwargs["version"] + self.entity_container_id = kwargs["entity_container_id"] + self.entity_object_id = kwargs["entity_object_id"] + self.resource_type = kwargs["resource_type"] + self.relationships = kwargs["relationships"] + self.asset_id = kwargs.get("asset_id", None) + + +class RunTypeV2Index(msrest.serialization.Model): + """RunTypeV2Index. + + All required parameters must be populated in order to send to Azure. + + :ivar orchestrator: Required. + :vartype orchestrator: str + :ivar traits: Required. Dictionary of :code:`<string>`. + :vartype traits: dict[str, str] + :ivar attribution: Required. + :vartype attribution: str + :ivar compute_type: Required. + :vartype compute_type: str + """ + + _validation = { + "orchestrator": {"required": True}, + "traits": {"required": True}, + "attribution": {"required": True}, + "compute_type": {"required": True}, + } + + _attribute_map = { + "orchestrator": {"key": "orchestrator", "type": "str"}, + "traits": {"key": "traits", "type": "{str}"}, + "attribution": {"key": "attribution", "type": "str"}, + "compute_type": {"key": "computeType", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword orchestrator: Required. + :paramtype orchestrator: str + :keyword traits: Required. Dictionary of :code:`<string>`. + :paramtype traits: dict[str, str] + :keyword attribution: Required. + :paramtype attribution: str + :keyword compute_type: Required. + :paramtype compute_type: str + """ + super(RunTypeV2Index, self).__init__(**kwargs) + self.orchestrator = kwargs["orchestrator"] + self.traits = kwargs["traits"] + self.attribution = kwargs["attribution"] + self.compute_type = kwargs["compute_type"] + + +class SingleShardFanoutData(msrest.serialization.Model): + """SingleShardFanoutData. + + :ivar next_skip: + :vartype next_skip: int + :ivar is_shard_done: + :vartype is_shard_done: bool + :ivar did_shard_fail: + :vartype did_shard_fail: bool + :ivar total_count: + :vartype total_count: long + """ + + _attribute_map = { + "next_skip": {"key": "nextSkip", "type": "int"}, + "is_shard_done": {"key": "isShardDone", "type": "bool"}, + "did_shard_fail": {"key": "didShardFail", "type": "bool"}, + "total_count": {"key": "totalCount", "type": "long"}, + } + + def __init__(self, **kwargs): + """ + :keyword next_skip: + :paramtype next_skip: int + :keyword is_shard_done: + :paramtype is_shard_done: bool + :keyword did_shard_fail: + :paramtype did_shard_fail: bool + :keyword total_count: + :paramtype total_count: long + """ + super(SingleShardFanoutData, self).__init__(**kwargs) + self.next_skip = kwargs.get("next_skip", None) + self.is_shard_done = kwargs.get("is_shard_done", None) + self.did_shard_fail = kwargs.get("did_shard_fail", None) + self.total_count = kwargs.get("total_count", None) + + +class StringContainsRequest(msrest.serialization.Model): + """StringContainsRequest. + + :ivar value_to_check: + :vartype value_to_check: str + :ivar columns_to_check: + :vartype columns_to_check: list[str] + """ + + _attribute_map = { + "value_to_check": {"key": "valueToCheck", "type": "str"}, + "columns_to_check": {"key": "columnsToCheck", "type": "[str]"}, + } + + def __init__(self, **kwargs): + """ + :keyword value_to_check: + :paramtype value_to_check: str + :keyword columns_to_check: + :paramtype columns_to_check: list[str] + """ + super(StringContainsRequest, self).__init__(**kwargs) + self.value_to_check = kwargs.get("value_to_check", None) + self.columns_to_check = kwargs.get("columns_to_check", None) + + +class StructuredInterfaceParameter(msrest.serialization.Model): + """StructuredInterfaceParameter. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar label: Required. + :vartype label: str + :ivar parameter_type: Required. Possible values include: "Int", "Double", "Bool", "String", + "Undefined". + :vartype parameter_type: str or ~index_service_apis.models.StructuredInterfaceParameterType + :ivar is_optional: Required. + :vartype is_optional: bool + :ivar default_value: Required. + :vartype default_value: str + :ivar lower_bound: Required. + :vartype lower_bound: str + :ivar upper_bound: Required. + :vartype upper_bound: str + :ivar enum_values: Required. + :vartype enum_values: list[str] + """ + + _validation = { + "name": {"required": True}, + "description": {"required": True}, + "label": {"required": True}, + "parameter_type": {"required": True}, + "is_optional": {"required": True}, + "default_value": {"required": True}, + "lower_bound": {"required": True}, + "upper_bound": {"required": True}, + "enum_values": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "label": {"key": "label", "type": "str"}, + "parameter_type": {"key": "parameterType", "type": "str"}, + "is_optional": {"key": "isOptional", "type": "bool"}, + "default_value": {"key": "defaultValue", "type": "str"}, + "lower_bound": {"key": "lowerBound", "type": "str"}, + "upper_bound": {"key": "upperBound", "type": "str"}, + "enum_values": {"key": "enumValues", "type": "[str]"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword label: Required. + :paramtype label: str + :keyword parameter_type: Required. Possible values include: "Int", "Double", "Bool", "String", + "Undefined". + :paramtype parameter_type: str or ~index_service_apis.models.StructuredInterfaceParameterType + :keyword is_optional: Required. + :paramtype is_optional: bool + :keyword default_value: Required. + :paramtype default_value: str + :keyword lower_bound: Required. + :paramtype lower_bound: str + :keyword upper_bound: Required. + :paramtype upper_bound: str + :keyword enum_values: Required. + :paramtype enum_values: list[str] + """ + super(StructuredInterfaceParameter, self).__init__(**kwargs) + self.name = kwargs["name"] + self.description = kwargs["description"] + self.label = kwargs["label"] + self.parameter_type = kwargs["parameter_type"] + self.is_optional = kwargs["is_optional"] + self.default_value = kwargs["default_value"] + self.lower_bound = kwargs["lower_bound"] + self.upper_bound = kwargs["upper_bound"] + self.enum_values = kwargs["enum_values"] + + +class TimeDeltaDto(msrest.serialization.Model): + """TimeDeltaDto. + + All required parameters must be populated in order to send to Azure. + + :ivar days: Required. + :vartype days: int + :ivar hours: Required. + :vartype hours: int + :ivar minutes: Required. + :vartype minutes: int + """ + + _validation = { + "days": {"required": True}, + "hours": {"required": True}, + "minutes": {"required": True}, + } + + _attribute_map = { + "days": {"key": "days", "type": "int"}, + "hours": {"key": "hours", "type": "int"}, + "minutes": {"key": "minutes", "type": "int"}, + } + + def __init__(self, **kwargs): + """ + :keyword days: Required. + :paramtype days: int + :keyword hours: Required. + :paramtype hours: int + :keyword minutes: Required. + :paramtype minutes: int + """ + super(TimeDeltaDto, self).__init__(**kwargs) + self.days = kwargs["days"] + self.hours = kwargs["hours"] + self.minutes = kwargs["minutes"] + + +class TimestampColumnDto(msrest.serialization.Model): + """TimestampColumnDto. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar format: Required. + :vartype format: str + """ + + _validation = { + "name": {"required": True}, + "format": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "format": {"key": "format", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword format: Required. + :paramtype format: str + """ + super(TimestampColumnDto, self).__init__(**kwargs) + self.name = kwargs["name"] + self.format = kwargs["format"] + + +class UnqueriableResourcesScope(msrest.serialization.Model): + """UnqueriableResourcesScope. + + :ivar resource_set: + :vartype resource_set: list[~index_service_apis.models.ResourceInformation] + """ + + _attribute_map = { + "resource_set": {"key": "resourceSet", "type": "[ResourceInformation]"}, + } + + def __init__(self, **kwargs): + """ + :keyword resource_set: + :paramtype resource_set: list[~index_service_apis.models.ResourceInformation] + """ + super(UnqueriableResourcesScope, self).__init__(**kwargs) + self.resource_set = kwargs.get("resource_set", None) + + +class Usage(msrest.serialization.Model): + """Usage. + + :ivar total_count: + :vartype total_count: long + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + } + + def __init__(self, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + """ + super(Usage, self).__init__(**kwargs) + self.total_count = kwargs.get("total_count", None) + + +class UserDto(msrest.serialization.Model): + """UserDto. + + All required parameters must be populated in order to send to Azure. + + :ivar user_object_id: Required. + :vartype user_object_id: str + :ivar user_tenant_id: Required. + :vartype user_tenant_id: str + :ivar user_name: Required. + :vartype user_name: str + """ + + _validation = { + "user_object_id": {"required": True}, + "user_tenant_id": {"required": True}, + "user_name": {"required": True}, + } + + _attribute_map = { + "user_object_id": {"key": "userObjectId", "type": "str"}, + "user_tenant_id": {"key": "userTenantId", "type": "str"}, + "user_name": {"key": "userName", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword user_object_id: Required. + :paramtype user_object_id: str + :keyword user_tenant_id: Required. + :paramtype user_tenant_id: str + :keyword user_name: Required. + :paramtype user_name: str + """ + super(UserDto, self).__init__(**kwargs) + self.user_object_id = kwargs["user_object_id"] + self.user_tenant_id = kwargs["user_tenant_id"] + self.user_name = kwargs["user_name"] + + +class UxPresenceResource(msrest.serialization.Model): + """UxPresenceResource. + + :ivar name: + :vartype name: str + :ivar resource_id: + :vartype resource_id: str + :ivar resource_type: + :vartype resource_type: str + :ivar region: + :vartype region: str + :ivar regions: + :vartype regions: list[~index_service_apis.models.ResourceRegion] + :ivar subscription_id: + :vartype subscription_id: str + :ivar resource_group_name: + :vartype resource_group_name: str + :ivar tags: A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + :ivar is_customer_managed: + :vartype is_customer_managed: bool + :ivar is_private_link_resource: + :vartype is_private_link_resource: bool + :ivar is_private_link_resource_behind_vnet: + :vartype is_private_link_resource_behind_vnet: bool + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "region": {"key": "region", "type": "str"}, + "regions": {"key": "regions", "type": "[ResourceRegion]"}, + "subscription_id": {"key": "subscriptionId", "type": "str"}, + "resource_group_name": {"key": "resourceGroupName", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "is_customer_managed": {"key": "isCustomerManaged", "type": "bool"}, + "is_private_link_resource": {"key": "isPrivateLinkResource", "type": "bool"}, + "is_private_link_resource_behind_vnet": {"key": "isPrivateLinkResourceBehindVnet", "type": "bool"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: + :paramtype name: str + :keyword resource_id: + :paramtype resource_id: str + :keyword resource_type: + :paramtype resource_type: str + :keyword region: + :paramtype region: str + :keyword regions: + :paramtype regions: list[~index_service_apis.models.ResourceRegion] + :keyword subscription_id: + :paramtype subscription_id: str + :keyword resource_group_name: + :paramtype resource_group_name: str + :keyword tags: A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + :keyword is_customer_managed: + :paramtype is_customer_managed: bool + :keyword is_private_link_resource: + :paramtype is_private_link_resource: bool + :keyword is_private_link_resource_behind_vnet: + :paramtype is_private_link_resource_behind_vnet: bool + """ + super(UxPresenceResource, self).__init__(**kwargs) + self.name = kwargs.get("name", None) + self.resource_id = kwargs.get("resource_id", None) + self.resource_type = kwargs.get("resource_type", None) + self.region = kwargs.get("region", None) + self.regions = kwargs.get("regions", None) + self.subscription_id = kwargs.get("subscription_id", None) + self.resource_group_name = kwargs.get("resource_group_name", None) + self.tags = kwargs.get("tags", None) + self.is_customer_managed = kwargs.get("is_customer_managed", None) + self.is_private_link_resource = kwargs.get("is_private_link_resource", None) + self.is_private_link_resource_behind_vnet = kwargs.get("is_private_link_resource_behind_vnet", None) + + +class UxWarmUpRequest(msrest.serialization.Model): + """UxWarmUpRequest. + + :ivar entity_types: + :vartype entity_types: list[str] + :ivar resource_ids: + :vartype resource_ids: list[str] + """ + + _attribute_map = { + "entity_types": {"key": "entityTypes", "type": "[str]"}, + "resource_ids": {"key": "resourceIds", "type": "[str]"}, + } + + def __init__(self, **kwargs): + """ + :keyword entity_types: + :paramtype entity_types: list[str] + :keyword resource_ids: + :paramtype resource_ids: list[str] + """ + super(UxWarmUpRequest, self).__init__(**kwargs) + self.entity_types = kwargs.get("entity_types", None) + self.resource_ids = kwargs.get("resource_ids", None) + + +class VersionedAttribute(msrest.serialization.Model): + """VersionedAttribute. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar version: Required. + :vartype version: str + """ + + _validation = { + "name": {"required": True}, + "version": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "version": {"key": "version", "type": "str"}, + } + + def __init__(self, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword version: Required. + :paramtype version: str + """ + super(VersionedAttribute, self).__init__(**kwargs) + self.name = kwargs["name"] + self.version = kwargs["version"] + + +class Webhook(msrest.serialization.Model): + """Webhook. + + 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 webhook_type: Has constant value: "AzureDevOps". + :vartype webhook_type: str + :ivar event_type: Required. + :vartype event_type: str + """ + + _validation = { + "webhook_type": {"required": True, "constant": True}, + "event_type": {"required": True}, + } + + _attribute_map = { + "webhook_type": {"key": "webhookType", "type": "str"}, + "event_type": {"key": "eventType", "type": "str"}, + } + + webhook_type = "AzureDevOps" + + def __init__(self, **kwargs): + """ + :keyword event_type: Required. + :paramtype event_type: str + """ + super(Webhook, self).__init__(**kwargs) + self.event_type = kwargs["event_type"] + + +class WorkspaceContextWarmUpRequest(msrest.serialization.Model): + """WorkspaceContextWarmUpRequest. + + :ivar discover_registries: + :vartype discover_registries: bool + """ + + _attribute_map = { + "discover_registries": {"key": "discoverRegistries", "type": "bool"}, + } + + def __init__(self, **kwargs): + """ + :keyword discover_registries: + :paramtype discover_registries: bool + """ + super(WorkspaceContextWarmUpRequest, self).__init__(**kwargs) + self.discover_registries = kwargs.get("discover_registries", None) diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models_py3.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models_py3.py new file mode 100644 index 00000000..515cd873 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/models/_models_py3.py @@ -0,0 +1,10478 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +import datetime +from typing import Any, Dict, List, Optional, Union + +import msrest.serialization + +from ._index_service_apis_enums import * + + +class BatchEndpointAnnotations(msrest.serialization.Model): + """BatchEndpointAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar scoring_uri: Required. + :vartype scoring_uri: str + :ivar location: Required. + :vartype location: str + :ivar last_modified_time: Required. + :vartype last_modified_time: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "scoring_uri": {"required": True}, + "location": {"required": True}, + "last_modified_time": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "scoring_uri": {"key": "scoringUri", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + scoring_uri: str, + location: str, + last_modified_time: datetime.datetime, + name: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword scoring_uri: Required. + :paramtype scoring_uri: str + :keyword location: Required. + :paramtype location: str + :keyword last_modified_time: Required. + :paramtype last_modified_time: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(BatchEndpointAnnotations, self).__init__(**kwargs) + self.scoring_uri = scoring_uri + self.location = location + self.last_modified_time = last_modified_time + self.name = name + self.description = description + self.archived = archived + self.tags = tags + + +class BatchEndpointProperties(msrest.serialization.Model): + """BatchEndpointProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "properties": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "properties": {"key": "properties", "type": "{str}"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, properties: Dict[str, str], creation_context: "CreationContext", **kwargs): + """ + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(BatchEndpointProperties, self).__init__(**kwargs) + self.properties = properties + self.creation_context = creation_context + + +class BatchendpointsUnversionedEntitiesResponse(msrest.serialization.Model): + """BatchendpointsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.BatchendpointsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[BatchendpointsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["BatchendpointsUnversionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.BatchendpointsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(BatchendpointsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class BatchendpointsUnversionedEntity(msrest.serialization.Model): + """BatchendpointsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.BatchendpointsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.BatchEndpointAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.BatchEndpointProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "BatchEndpointAnnotations"}, + "properties": {"key": "properties", "type": "BatchEndpointProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "BatchendpointsUnversionedEntityKind"], + annotations: "BatchEndpointAnnotations", + properties: "BatchEndpointProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.BatchendpointsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.BatchEndpointAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.BatchEndpointProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(BatchendpointsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class Compute(msrest.serialization.Model): + """Compute. + + All required parameters must be populated in order to send to Azure. + + :ivar target: Required. + :vartype target: str + :ivar target_type: Required. + :vartype target_type: str + :ivar vm_size: Required. + :vartype vm_size: str + :ivar instance_type: Required. + :vartype instance_type: str + :ivar instance_count: Required. + :vartype instance_count: int + :ivar gpu_count: Required. + :vartype gpu_count: int + :ivar priority: Required. + :vartype priority: str + :ivar region: Required. + :vartype region: str + :ivar arm_id: Required. + :vartype arm_id: str + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + """ + + _validation = { + "target": {"required": True}, + "target_type": {"required": True}, + "vm_size": {"required": True}, + "instance_type": {"required": True}, + "instance_count": {"required": True}, + "gpu_count": {"required": True}, + "priority": {"required": True}, + "region": {"required": True}, + "arm_id": {"required": True}, + "properties": {"required": True}, + } + + _attribute_map = { + "target": {"key": "target", "type": "str"}, + "target_type": {"key": "targetType", "type": "str"}, + "vm_size": {"key": "vmSize", "type": "str"}, + "instance_type": {"key": "instanceType", "type": "str"}, + "instance_count": {"key": "instanceCount", "type": "int"}, + "gpu_count": {"key": "gpuCount", "type": "int"}, + "priority": {"key": "priority", "type": "str"}, + "region": {"key": "region", "type": "str"}, + "arm_id": {"key": "armId", "type": "str"}, + "properties": {"key": "properties", "type": "{str}"}, + } + + def __init__( + self, + *, + target: str, + target_type: str, + vm_size: str, + instance_type: str, + instance_count: int, + gpu_count: int, + priority: str, + region: str, + arm_id: str, + properties: Dict[str, str], + **kwargs + ): + """ + :keyword target: Required. + :paramtype target: str + :keyword target_type: Required. + :paramtype target_type: str + :keyword vm_size: Required. + :paramtype vm_size: str + :keyword instance_type: Required. + :paramtype instance_type: str + :keyword instance_count: Required. + :paramtype instance_count: int + :keyword gpu_count: Required. + :paramtype gpu_count: int + :keyword priority: Required. + :paramtype priority: str + :keyword region: Required. + :paramtype region: str + :keyword arm_id: Required. + :paramtype arm_id: str + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + """ + super(Compute, self).__init__(**kwargs) + self.target = target + self.target_type = target_type + self.vm_size = vm_size + self.instance_type = instance_type + self.instance_count = instance_count + self.gpu_count = gpu_count + self.priority = priority + self.region = region + self.arm_id = arm_id + self.properties = properties + + +class ComputeRequest(msrest.serialization.Model): + """ComputeRequest. + + All required parameters must be populated in order to send to Azure. + + :ivar node_count: Required. + :vartype node_count: int + :ivar gpu_count: Required. + :vartype gpu_count: int + """ + + _validation = { + "node_count": {"required": True}, + "gpu_count": {"required": True}, + } + + _attribute_map = { + "node_count": {"key": "nodeCount", "type": "int"}, + "gpu_count": {"key": "gpuCount", "type": "int"}, + } + + def __init__(self, *, node_count: int, gpu_count: int, **kwargs): + """ + :keyword node_count: Required. + :paramtype node_count: int + :keyword gpu_count: Required. + :paramtype gpu_count: int + """ + super(ComputeRequest, self).__init__(**kwargs) + self.node_count = node_count + self.gpu_count = gpu_count + + +class ContainerResourceRequirements(msrest.serialization.Model): + """ContainerResourceRequirements. + + All required parameters must be populated in order to send to Azure. + + :ivar cpu: Required. + :vartype cpu: float + :ivar cpu_limit: Required. + :vartype cpu_limit: float + :ivar memory_in_gb: Required. + :vartype memory_in_gb: float + :ivar memory_in_gb_limit: Required. + :vartype memory_in_gb_limit: float + :ivar gpu_enabled: Required. + :vartype gpu_enabled: bool + :ivar gpu: Required. + :vartype gpu: int + :ivar fpga: Required. + :vartype fpga: int + """ + + _validation = { + "cpu": {"required": True}, + "cpu_limit": {"required": True}, + "memory_in_gb": {"required": True}, + "memory_in_gb_limit": {"required": True}, + "gpu_enabled": {"required": True}, + "gpu": {"required": True}, + "fpga": {"required": True}, + } + + _attribute_map = { + "cpu": {"key": "cpu", "type": "float"}, + "cpu_limit": {"key": "cpuLimit", "type": "float"}, + "memory_in_gb": {"key": "memoryInGB", "type": "float"}, + "memory_in_gb_limit": {"key": "memoryInGBLimit", "type": "float"}, + "gpu_enabled": {"key": "gpuEnabled", "type": "bool"}, + "gpu": {"key": "gpu", "type": "int"}, + "fpga": {"key": "fpga", "type": "int"}, + } + + def __init__( + self, + *, + cpu: float, + cpu_limit: float, + memory_in_gb: float, + memory_in_gb_limit: float, + gpu_enabled: bool, + gpu: int, + fpga: int, + **kwargs + ): + """ + :keyword cpu: Required. + :paramtype cpu: float + :keyword cpu_limit: Required. + :paramtype cpu_limit: float + :keyword memory_in_gb: Required. + :paramtype memory_in_gb: float + :keyword memory_in_gb_limit: Required. + :paramtype memory_in_gb_limit: float + :keyword gpu_enabled: Required. + :paramtype gpu_enabled: bool + :keyword gpu: Required. + :paramtype gpu: int + :keyword fpga: Required. + :paramtype fpga: int + """ + super(ContainerResourceRequirements, self).__init__(**kwargs) + self.cpu = cpu + self.cpu_limit = cpu_limit + self.memory_in_gb = memory_in_gb + self.memory_in_gb_limit = memory_in_gb_limit + self.gpu_enabled = gpu_enabled + self.gpu = gpu + self.fpga = fpga + + +class ControlOutput(msrest.serialization.Model): + """ControlOutput. + + :ivar name: + :vartype name: str + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + } + + def __init__(self, *, name: Optional[str] = None, **kwargs): + """ + :keyword name: + :paramtype name: str + """ + super(ControlOutput, self).__init__(**kwargs) + self.name = name + + +class CreatedBy(msrest.serialization.Model): + """CreatedBy. + + :ivar user_object_id: + :vartype user_object_id: str + :ivar user_tenant_id: + :vartype user_tenant_id: str + :ivar user_name: + :vartype user_name: str + """ + + _attribute_map = { + "user_object_id": {"key": "userObjectId", "type": "str"}, + "user_tenant_id": {"key": "userTenantId", "type": "str"}, + "user_name": {"key": "userName", "type": "str"}, + } + + def __init__( + self, + *, + user_object_id: Optional[str] = None, + user_tenant_id: Optional[str] = None, + user_name: Optional[str] = None, + **kwargs + ): + """ + :keyword user_object_id: + :paramtype user_object_id: str + :keyword user_tenant_id: + :paramtype user_tenant_id: str + :keyword user_name: + :paramtype user_name: str + """ + super(CreatedBy, self).__init__(**kwargs) + self.user_object_id = user_object_id + self.user_tenant_id = user_tenant_id + self.user_name = user_name + + +class CreatedBy1(msrest.serialization.Model): + """CreatedBy1. + + All required parameters must be populated in order to send to Azure. + + :ivar user_object_id: Required. + :vartype user_object_id: str + :ivar user_tenant_id: Required. + :vartype user_tenant_id: str + :ivar user_name: Required. + :vartype user_name: str + """ + + _validation = { + "user_object_id": {"required": True}, + "user_tenant_id": {"required": True}, + "user_name": {"required": True}, + } + + _attribute_map = { + "user_object_id": {"key": "userObjectId", "type": "str"}, + "user_tenant_id": {"key": "userTenantId", "type": "str"}, + "user_name": {"key": "userName", "type": "str"}, + } + + def __init__(self, *, user_object_id: str, user_tenant_id: str, user_name: str, **kwargs): + """ + :keyword user_object_id: Required. + :paramtype user_object_id: str + :keyword user_tenant_id: Required. + :paramtype user_tenant_id: str + :keyword user_name: Required. + :paramtype user_name: str + """ + super(CreatedBy1, self).__init__(**kwargs) + self.user_object_id = user_object_id + self.user_tenant_id = user_tenant_id + self.user_name = user_name + + +class CreationContext(msrest.serialization.Model): + """CreationContext. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar created_time: + :vartype created_time: ~datetime.datetime + :ivar created_by: + :vartype created_by: ~index_service_apis.models.CreatedBy + :ivar creation_source: + :vartype creation_source: str + """ + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "created_time": {"key": "createdTime", "type": "iso-8601"}, + "created_by": {"key": "createdBy", "type": "CreatedBy"}, + "creation_source": {"key": "creationSource", "type": "str"}, + } + + def __init__( + self, + *, + additional_properties: Optional[Dict[str, Any]] = None, + created_time: Optional[datetime.datetime] = None, + created_by: Optional["CreatedBy"] = None, + creation_source: Optional[str] = None, + **kwargs + ): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword created_time: + :paramtype created_time: ~datetime.datetime + :keyword created_by: + :paramtype created_by: ~index_service_apis.models.CreatedBy + :keyword creation_source: + :paramtype creation_source: str + """ + super(CreationContext, self).__init__(**kwargs) + self.additional_properties = additional_properties + self.created_time = created_time + self.created_by = created_by + self.creation_source = creation_source + + +class CronTrigger(msrest.serialization.Model): + """CronTrigger. + + :ivar expression: + :vartype expression: str + """ + + _attribute_map = { + "expression": {"key": "expression", "type": "str"}, + } + + def __init__(self, *, expression: Optional[str] = None, **kwargs): + """ + :keyword expression: + :paramtype expression: str + """ + super(CronTrigger, self).__init__(**kwargs) + self.expression = expression + + +class CrossRegionIndexEntitiesRequest(msrest.serialization.Model): + """CrossRegionIndexEntitiesRequest. + + :ivar resource_ids: + :vartype resource_ids: list[~index_service_apis.models.ResourceInformation] + :ivar index_entities_request: + :vartype index_entities_request: ~index_service_apis.models.IndexEntitiesRequest + """ + + _attribute_map = { + "resource_ids": {"key": "resourceIds", "type": "[ResourceInformation]"}, + "index_entities_request": {"key": "indexEntitiesRequest", "type": "IndexEntitiesRequest"}, + } + + def __init__( + self, + *, + resource_ids: Optional[List["ResourceInformation"]] = None, + index_entities_request: Optional["IndexEntitiesRequest"] = None, + **kwargs + ): + """ + :keyword resource_ids: + :paramtype resource_ids: list[~index_service_apis.models.ResourceInformation] + :keyword index_entities_request: + :paramtype index_entities_request: ~index_service_apis.models.IndexEntitiesRequest + """ + super(CrossRegionIndexEntitiesRequest, self).__init__(**kwargs) + self.resource_ids = resource_ids + self.index_entities_request = index_entities_request + + +class CrossRegionIndexEntitiesResponse(msrest.serialization.Model): + """CrossRegionIndexEntitiesResponse. + + :ivar index_entities_response: + :vartype index_entities_response: ~index_service_apis.models.IndexEntitiesResponse + :ivar regional_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype regional_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar shard_errors: Dictionary of + <components·1fu9hkf·schemas·crossregionindexentitiesresponse·properties·sharderrors·additionalproperties>. + :vartype shard_errors: dict[str, dict[str, ~index_service_apis.models.ErrorResponse]] + :ivar number_of_resources_not_included_in_search: + :vartype number_of_resources_not_included_in_search: int + """ + + _attribute_map = { + "index_entities_response": {"key": "indexEntitiesResponse", "type": "IndexEntitiesResponse"}, + "regional_errors": {"key": "regionalErrors", "type": "{ErrorResponse}"}, + "shard_errors": {"key": "shardErrors", "type": "{{ErrorResponse}}"}, + "number_of_resources_not_included_in_search": {"key": "numberOfResourcesNotIncludedInSearch", "type": "int"}, + } + + def __init__( + self, + *, + index_entities_response: Optional["IndexEntitiesResponse"] = None, + regional_errors: Optional[Dict[str, "ErrorResponse"]] = None, + shard_errors: Optional[Dict[str, Dict[str, "ErrorResponse"]]] = None, + number_of_resources_not_included_in_search: Optional[int] = None, + **kwargs + ): + """ + :keyword index_entities_response: + :paramtype index_entities_response: ~index_service_apis.models.IndexEntitiesResponse + :keyword regional_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype regional_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword shard_errors: Dictionary of + <components·1fu9hkf·schemas·crossregionindexentitiesresponse·properties·sharderrors·additionalproperties>. + :paramtype shard_errors: dict[str, dict[str, ~index_service_apis.models.ErrorResponse]] + :keyword number_of_resources_not_included_in_search: + :paramtype number_of_resources_not_included_in_search: int + """ + super(CrossRegionIndexEntitiesResponse, self).__init__(**kwargs) + self.index_entities_response = index_entities_response + self.regional_errors = regional_errors + self.shard_errors = shard_errors + self.number_of_resources_not_included_in_search = number_of_resources_not_included_in_search + + +class CudaAttribute(msrest.serialization.Model): + """CudaAttribute. + + All required parameters must be populated in order to send to Azure. + + :ivar cuda_version: Required. + :vartype cuda_version: str + :ivar cu_dnn_version: Required. + :vartype cu_dnn_version: str + :ivar nccl_version: Required. + :vartype nccl_version: str + """ + + _validation = { + "cuda_version": {"required": True}, + "cu_dnn_version": {"required": True}, + "nccl_version": {"required": True}, + } + + _attribute_map = { + "cuda_version": {"key": "cudaVersion", "type": "str"}, + "cu_dnn_version": {"key": "cuDnnVersion", "type": "str"}, + "nccl_version": {"key": "ncclVersion", "type": "str"}, + } + + def __init__(self, *, cuda_version: str, cu_dnn_version: str, nccl_version: str, **kwargs): + """ + :keyword cuda_version: Required. + :paramtype cuda_version: str + :keyword cu_dnn_version: Required. + :paramtype cu_dnn_version: str + :keyword nccl_version: Required. + :paramtype nccl_version: str + """ + super(CudaAttribute, self).__init__(**kwargs) + self.cuda_version = cuda_version + self.cu_dnn_version = cu_dnn_version + self.nccl_version = nccl_version + + +class DatasetAnnotations(msrest.serialization.Model): + """DatasetAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar modified_time: Required. + :vartype modified_time: ~datetime.datetime + :ivar modified_by: Required. + :vartype modified_by: ~index_service_apis.models.UserDto + :ivar next_version_id: Required. + :vartype next_version_id: str + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar labels: Required. Dictionary of :code:`<string>`. + :vartype labels: dict[str, str] + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "modified_time": {"required": True}, + "modified_by": {"required": True}, + "next_version_id": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "labels": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "modified_time": {"key": "modifiedTime", "type": "iso-8601"}, + "modified_by": {"key": "modifiedBy", "type": "UserDto"}, + "next_version_id": {"key": "nextVersionId", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "labels": {"key": "labels", "type": "{str}"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + modified_time: datetime.datetime, + modified_by: "UserDto", + next_version_id: str, + name: str, + description: str, + labels: Dict[str, str], + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword modified_time: Required. + :paramtype modified_time: ~datetime.datetime + :keyword modified_by: Required. + :paramtype modified_by: ~index_service_apis.models.UserDto + :keyword next_version_id: Required. + :paramtype next_version_id: str + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword labels: Required. Dictionary of :code:`<string>`. + :paramtype labels: dict[str, str] + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(DatasetAnnotations, self).__init__(**kwargs) + self.modified_time = modified_time + self.modified_by = modified_by + self.next_version_id = next_version_id + self.name = name + self.description = description + self.labels = labels + self.archived = archived + self.tags = tags + + +class DatasetProperties(msrest.serialization.Model): + """DatasetProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar subtype: Required. + :vartype subtype: str + :ivar is_registered: Required. + :vartype is_registered: bool + :ivar data_type: Required. + :vartype data_type: str + :ivar is_v2: Required. + :vartype is_v2: bool + :ivar name_lower_case: Required. + :vartype name_lower_case: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "subtype": {"required": True}, + "is_registered": {"required": True}, + "data_type": {"required": True}, + "is_v2": {"required": True}, + "name_lower_case": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "subtype": {"key": "subtype", "type": "str"}, + "is_registered": {"key": "isRegistered", "type": "bool"}, + "data_type": {"key": "dataType", "type": "str"}, + "is_v2": {"key": "isV2", "type": "bool"}, + "name_lower_case": {"key": "nameLowerCase", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__( + self, + *, + subtype: str, + is_registered: bool, + data_type: str, + is_v2: bool, + name_lower_case: str, + creation_context: "CreationContext", + **kwargs + ): + """ + :keyword subtype: Required. + :paramtype subtype: str + :keyword is_registered: Required. + :paramtype is_registered: bool + :keyword data_type: Required. + :paramtype data_type: str + :keyword is_v2: Required. + :paramtype is_v2: bool + :keyword name_lower_case: Required. + :paramtype name_lower_case: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(DatasetProperties, self).__init__(**kwargs) + self.subtype = subtype + self.is_registered = is_registered + self.data_type = data_type + self.is_v2 = is_v2 + self.name_lower_case = name_lower_case + self.creation_context = creation_context + + +class DatasetReference(msrest.serialization.Model): + """DatasetReference. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar id: Required. + :vartype id: str + """ + + _validation = { + "name": {"required": True}, + "id": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "id": {"key": "id", "type": "str"}, + } + + def __init__(self, *, name: str, id: str, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword id: Required. + :paramtype id: str + """ + super(DatasetReference, self).__init__(**kwargs) + self.name = name + self.id = id + + +class DatasetsVersionedEntitiesResponse(msrest.serialization.Model): + """DatasetsVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.DatasetsVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[DatasetsVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["DatasetsVersionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.DatasetsVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(DatasetsVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class DatasetsVersionedEntity(msrest.serialization.Model): + """DatasetsVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.DatasetsVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.DatasetAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.DatasetProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "DatasetAnnotations"}, + "properties": {"key": "properties", "type": "DatasetProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "DatasetsVersionedEntityKind"], + annotations: "DatasetAnnotations", + properties: "DatasetProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.DatasetsVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.DatasetAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.DatasetProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(DatasetsVersionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class DataStoreAnnotations(msrest.serialization.Model): + """DataStoreAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar data_store_type: Required. Possible values include: "AzureBlob", "AzureFile", + "GlusterFs", "AzureDataLake", "AzureMySql", "Custom", "Hdfs", "AzureSqlDatabase", + "AzurePostgreSql", "DBFS", "AzureDataLakeGen2". + :vartype data_store_type: str or ~index_service_apis.models.DataStoreAnnotationsDataStoreType + :ivar data_store_type_name: Required. + :vartype data_store_type_name: str + :ivar storage_name: Required. + :vartype storage_name: str + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "data_store_type": {"required": True}, + "data_store_type_name": {"required": True}, + "storage_name": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "data_store_type": {"key": "dataStoreType", "type": "str"}, + "data_store_type_name": {"key": "dataStoreTypeName", "type": "str"}, + "storage_name": {"key": "storageName", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + data_store_type: Union[str, "DataStoreAnnotationsDataStoreType"], + data_store_type_name: str, + storage_name: str, + name: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword data_store_type: Required. Possible values include: "AzureBlob", "AzureFile", + "GlusterFs", "AzureDataLake", "AzureMySql", "Custom", "Hdfs", "AzureSqlDatabase", + "AzurePostgreSql", "DBFS", "AzureDataLakeGen2". + :paramtype data_store_type: str or ~index_service_apis.models.DataStoreAnnotationsDataStoreType + :keyword data_store_type_name: Required. + :paramtype data_store_type_name: str + :keyword storage_name: Required. + :paramtype storage_name: str + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(DataStoreAnnotations, self).__init__(**kwargs) + self.data_store_type = data_store_type + self.data_store_type_name = data_store_type_name + self.storage_name = storage_name + self.name = name + self.description = description + self.archived = archived + self.tags = tags + + +class DataStoreProperties(msrest.serialization.Model): + """DataStoreProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "creation_context": {"required": True}, + } + + _attribute_map = { + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, creation_context: "CreationContext", **kwargs): + """ + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(DataStoreProperties, self).__init__(**kwargs) + self.creation_context = creation_context + + +class DatastoresUnversionedEntitiesResponse(msrest.serialization.Model): + """DatastoresUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.DatastoresUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[DatastoresUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["DatastoresUnversionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.DatastoresUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(DatastoresUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class DatastoresUnversionedEntity(msrest.serialization.Model): + """DatastoresUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.DatastoresUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.DataStoreAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.DataStoreProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "DataStoreAnnotations"}, + "properties": {"key": "properties", "type": "DataStoreProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "DatastoresUnversionedEntityKind"], + annotations: "DataStoreAnnotations", + properties: "DataStoreProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.DatastoresUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.DataStoreAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.DataStoreProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(DatastoresUnversionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class DebugInfoResponse(msrest.serialization.Model): + """DebugInfoResponse. + + :ivar type: + :vartype type: str + :ivar message: + :vartype message: str + :ivar stack_trace: + :vartype stack_trace: str + :ivar inner_exception: + :vartype inner_exception: ~index_service_apis.models.DebugInfoResponse + :ivar data: Dictionary of :code:`<any>`. + :vartype data: dict[str, any] + :ivar error_response: + :vartype error_response: ~index_service_apis.models.ErrorResponse + """ + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "stack_trace": {"key": "stackTrace", "type": "str"}, + "inner_exception": {"key": "innerException", "type": "DebugInfoResponse"}, + "data": {"key": "data", "type": "{object}"}, + "error_response": {"key": "errorResponse", "type": "ErrorResponse"}, + } + + def __init__( + self, + *, + type: Optional[str] = None, + message: Optional[str] = None, + stack_trace: Optional[str] = None, + inner_exception: Optional["DebugInfoResponse"] = None, + data: Optional[Dict[str, Any]] = None, + error_response: Optional["ErrorResponse"] = None, + **kwargs + ): + """ + :keyword type: + :paramtype type: str + :keyword message: + :paramtype message: str + :keyword stack_trace: + :paramtype stack_trace: str + :keyword inner_exception: + :paramtype inner_exception: ~index_service_apis.models.DebugInfoResponse + :keyword data: Dictionary of :code:`<any>`. + :paramtype data: dict[str, any] + :keyword error_response: + :paramtype error_response: ~index_service_apis.models.ErrorResponse + """ + super(DebugInfoResponse, self).__init__(**kwargs) + self.type = type + self.message = message + self.stack_trace = stack_trace + self.inner_exception = inner_exception + self.data = data + self.error_response = error_response + + +class DefinitionAnnotations(msrest.serialization.Model): + """DefinitionAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__(self, *, description: str, archived: bool, tags: Dict[str, str], **kwargs): + """ + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(DefinitionAnnotations, self).__init__(**kwargs) + self.description = description + self.archived = archived + self.tags = tags + + +class DefinitionProperties(msrest.serialization.Model): + """DefinitionProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar automatically_saved: Required. + :vartype automatically_saved: bool + :ivar definition_hash: Required. + :vartype definition_hash: str + :ivar environment_attributes: Required. + :vartype environment_attributes: ~index_service_apis.models.EnvironmentAttributes + :ivar stage: Required. + :vartype stage: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "automatically_saved": {"required": True}, + "definition_hash": {"required": True}, + "environment_attributes": {"required": True}, + "stage": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "automatically_saved": {"key": "automaticallySaved", "type": "bool"}, + "definition_hash": {"key": "definitionHash", "type": "str"}, + "environment_attributes": {"key": "environmentAttributes", "type": "EnvironmentAttributes"}, + "stage": {"key": "stage", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__( + self, + *, + automatically_saved: bool, + definition_hash: str, + environment_attributes: "EnvironmentAttributes", + stage: str, + creation_context: "CreationContext", + **kwargs + ): + """ + :keyword automatically_saved: Required. + :paramtype automatically_saved: bool + :keyword definition_hash: Required. + :paramtype definition_hash: str + :keyword environment_attributes: Required. + :paramtype environment_attributes: ~index_service_apis.models.EnvironmentAttributes + :keyword stage: Required. + :paramtype stage: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(DefinitionProperties, self).__init__(**kwargs) + self.automatically_saved = automatically_saved + self.definition_hash = definition_hash + self.environment_attributes = environment_attributes + self.stage = stage + self.creation_context = creation_context + + +class EndpointComputeTarget(msrest.serialization.Model): + """EndpointComputeTarget. + + All required parameters must be populated in order to send to Azure. + + :ivar namespace: Required. + :vartype namespace: str + :ivar compute_target_name: Required. + :vartype compute_target_name: str + """ + + _validation = { + "namespace": {"required": True}, + "compute_target_name": {"required": True}, + } + + _attribute_map = { + "namespace": {"key": "namespace", "type": "str"}, + "compute_target_name": {"key": "computeTargetName", "type": "str"}, + } + + def __init__(self, *, namespace: str, compute_target_name: str, **kwargs): + """ + :keyword namespace: Required. + :paramtype namespace: str + :keyword compute_target_name: Required. + :paramtype compute_target_name: str + """ + super(EndpointComputeTarget, self).__init__(**kwargs) + self.namespace = namespace + self.compute_target_name = compute_target_name + + +class EnvironmentAttributes(msrest.serialization.Model): + """EnvironmentAttributes. + + All required parameters must be populated in order to send to Azure. + + :ivar machine_learning_framework: Required. + :vartype machine_learning_framework: ~index_service_apis.models.VersionedAttribute + :ivar mpi: Required. + :vartype mpi: ~index_service_apis.models.VersionedAttribute + :ivar runtime: Required. + :vartype runtime: ~index_service_apis.models.VersionedAttribute + :ivar cuda: Required. + :vartype cuda: ~index_service_apis.models.CudaAttribute + :ivar purpose: Required. + :vartype purpose: ~index_service_apis.models.Purpose + :ivar os: Required. + :vartype os: ~index_service_apis.models.VersionedAttribute + """ + + _validation = { + "machine_learning_framework": {"required": True}, + "mpi": {"required": True}, + "runtime": {"required": True}, + "cuda": {"required": True}, + "purpose": {"required": True}, + "os": {"required": True}, + } + + _attribute_map = { + "machine_learning_framework": {"key": "machineLearningFramework", "type": "VersionedAttribute"}, + "mpi": {"key": "mpi", "type": "VersionedAttribute"}, + "runtime": {"key": "runtime", "type": "VersionedAttribute"}, + "cuda": {"key": "cuda", "type": "CudaAttribute"}, + "purpose": {"key": "purpose", "type": "Purpose"}, + "os": {"key": "os", "type": "VersionedAttribute"}, + } + + def __init__( + self, + *, + machine_learning_framework: "VersionedAttribute", + mpi: "VersionedAttribute", + runtime: "VersionedAttribute", + cuda: "CudaAttribute", + purpose: "Purpose", + os: "VersionedAttribute", + **kwargs + ): + """ + :keyword machine_learning_framework: Required. + :paramtype machine_learning_framework: ~index_service_apis.models.VersionedAttribute + :keyword mpi: Required. + :paramtype mpi: ~index_service_apis.models.VersionedAttribute + :keyword runtime: Required. + :paramtype runtime: ~index_service_apis.models.VersionedAttribute + :keyword cuda: Required. + :paramtype cuda: ~index_service_apis.models.CudaAttribute + :keyword purpose: Required. + :paramtype purpose: ~index_service_apis.models.Purpose + :keyword os: Required. + :paramtype os: ~index_service_apis.models.VersionedAttribute + """ + super(EnvironmentAttributes, self).__init__(**kwargs) + self.machine_learning_framework = machine_learning_framework + self.mpi = mpi + self.runtime = runtime + self.cuda = cuda + self.purpose = purpose + self.os = os + + +class EnvironmentsVersionedEntitiesResponse(msrest.serialization.Model): + """EnvironmentsVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.EnvironmentsVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[EnvironmentsVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["EnvironmentsVersionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.EnvironmentsVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(EnvironmentsVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class EnvironmentsVersionedEntity(msrest.serialization.Model): + """EnvironmentsVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.EnvironmentsVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.DefinitionAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.DefinitionProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "DefinitionAnnotations"}, + "properties": {"key": "properties", "type": "DefinitionProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "EnvironmentsVersionedEntityKind"], + annotations: "DefinitionAnnotations", + properties: "DefinitionProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.EnvironmentsVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.DefinitionAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.DefinitionProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(EnvironmentsVersionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class ErrorAdditionalInfo(msrest.serialization.Model): + """ErrorAdditionalInfo. + + :ivar type: + :vartype type: str + :ivar info: Anything. + :vartype info: any + """ + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "info": {"key": "info", "type": "object"}, + } + + def __init__(self, *, type: Optional[str] = None, info: Optional[Any] = None, **kwargs): + """ + :keyword type: + :paramtype type: str + :keyword info: Anything. + :paramtype info: any + """ + super(ErrorAdditionalInfo, self).__init__(**kwargs) + self.type = type + self.info = info + + +class ErrorResponse(msrest.serialization.Model): + """ErrorResponse. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar error: + :vartype error: ~index_service_apis.models.RootError + :ivar correlation: Dictionary of :code:`<string>`. + :vartype correlation: dict[str, str] + :ivar environment: + :vartype environment: str + :ivar location: + :vartype location: str + :ivar time: + :vartype time: ~datetime.datetime + :ivar component_name: + :vartype component_name: str + """ + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "error": {"key": "error", "type": "RootError"}, + "correlation": {"key": "correlation", "type": "{str}"}, + "environment": {"key": "environment", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "time": {"key": "time", "type": "iso-8601"}, + "component_name": {"key": "componentName", "type": "str"}, + } + + def __init__( + self, + *, + additional_properties: Optional[Dict[str, Any]] = None, + error: Optional["RootError"] = None, + correlation: Optional[Dict[str, str]] = None, + environment: Optional[str] = None, + location: Optional[str] = None, + time: Optional[datetime.datetime] = None, + component_name: Optional[str] = None, + **kwargs + ): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword error: + :paramtype error: ~index_service_apis.models.RootError + :keyword correlation: Dictionary of :code:`<string>`. + :paramtype correlation: dict[str, str] + :keyword environment: + :paramtype environment: str + :keyword location: + :paramtype location: str + :keyword time: + :paramtype time: ~datetime.datetime + :keyword component_name: + :paramtype component_name: str + """ + super(ErrorResponse, self).__init__(**kwargs) + self.additional_properties = additional_properties + self.error = error + self.correlation = correlation + self.environment = environment + self.location = location + self.time = time + self.component_name = component_name + + +class ExperimentStatus(msrest.serialization.Model): + """ExperimentStatus. + + :ivar status_code: Possible values include: "NotStarted", "Running", "Failed", "Finished", + "Canceled", "Failing". + :vartype status_code: str or ~index_service_apis.models.ExperimentStatusCode + :ivar status_detail: + :vartype status_detail: str + :ivar creation_time: + :vartype creation_time: ~datetime.datetime + :ivar end_time: + :vartype end_time: ~datetime.datetime + :ivar run_history_error_code: + :vartype run_history_error_code: str + """ + + _attribute_map = { + "status_code": {"key": "statusCode", "type": "str"}, + "status_detail": {"key": "statusDetail", "type": "str"}, + "creation_time": {"key": "creationTime", "type": "iso-8601"}, + "end_time": {"key": "endTime", "type": "iso-8601"}, + "run_history_error_code": {"key": "runHistoryErrorCode", "type": "str"}, + } + + def __init__( + self, + *, + status_code: Optional[Union[str, "ExperimentStatusCode"]] = None, + status_detail: Optional[str] = None, + creation_time: Optional[datetime.datetime] = None, + end_time: Optional[datetime.datetime] = None, + run_history_error_code: Optional[str] = None, + **kwargs + ): + """ + :keyword status_code: Possible values include: "NotStarted", "Running", "Failed", "Finished", + "Canceled", "Failing". + :paramtype status_code: str or ~index_service_apis.models.ExperimentStatusCode + :keyword status_detail: + :paramtype status_detail: str + :keyword creation_time: + :paramtype creation_time: ~datetime.datetime + :keyword end_time: + :paramtype end_time: ~datetime.datetime + :keyword run_history_error_code: + :paramtype run_history_error_code: str + """ + super(ExperimentStatus, self).__init__(**kwargs) + self.status_code = status_code + self.status_detail = status_detail + self.creation_time = creation_time + self.end_time = end_time + self.run_history_error_code = run_history_error_code + + +class Feature(msrest.serialization.Model): + """Feature. + + All required parameters must be populated in order to send to Azure. + + :ivar feature_name: Required. + :vartype feature_name: str + :ivar description: Required. + :vartype description: str + :ivar data_type: Required. Possible values include: "String", "Integer", "Long", "Float", + "Double", "Binary", "Datetime", "Boolean". + :vartype data_type: str or ~index_service_apis.models.FeatureDataType + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "feature_name": {"required": True}, + "description": {"required": True}, + "data_type": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "feature_name": {"key": "featureName", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "data_type": {"key": "dataType", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + feature_name: str, + description: str, + data_type: Union[str, "FeatureDataType"], + tags: Dict[str, str], + **kwargs + ): + """ + :keyword feature_name: Required. + :paramtype feature_name: str + :keyword description: Required. + :paramtype description: str + :keyword data_type: Required. Possible values include: "String", "Integer", "Long", "Float", + "Double", "Binary", "Datetime", "Boolean". + :paramtype data_type: str or ~index_service_apis.models.FeatureDataType + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(Feature, self).__init__(**kwargs) + self.feature_name = feature_name + self.description = description + self.data_type = data_type + self.tags = tags + + +class FeatureentitiesVersionedEntitiesResponse(msrest.serialization.Model): + """FeatureentitiesVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.FeatureentitiesVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[FeatureentitiesVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["FeatureentitiesVersionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.FeatureentitiesVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(FeatureentitiesVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class FeatureentitiesVersionedEntity(msrest.serialization.Model): + """FeatureentitiesVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.FeatureentitiesVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.FeatureEntityVersionProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "FeatureEntityVersionAnnotations"}, + "properties": {"key": "properties", "type": "FeatureEntityVersionProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "FeatureentitiesVersionedEntityKind"], + annotations: "FeatureEntityVersionAnnotations", + properties: "FeatureEntityVersionProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.FeatureentitiesVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.FeatureEntityVersionProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(FeatureentitiesVersionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class FeatureEntityVersionAnnotations(msrest.serialization.Model): + """FeatureEntityVersionAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar actual_name: Required. + :vartype actual_name: str + :ivar index_columns: Required. + :vartype index_columns: list[~index_service_apis.models.IndexColumnDto] + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "actual_name": {"required": True}, + "index_columns": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "actual_name": {"key": "actualName", "type": "str"}, + "index_columns": {"key": "indexColumns", "type": "[IndexColumnDto]"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + actual_name: str, + index_columns: List["IndexColumnDto"], + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword actual_name: Required. + :paramtype actual_name: str + :keyword index_columns: Required. + :paramtype index_columns: list[~index_service_apis.models.IndexColumnDto] + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(FeatureEntityVersionAnnotations, self).__init__(**kwargs) + self.actual_name = actual_name + self.index_columns = index_columns + self.description = description + self.archived = archived + self.tags = tags + + +class FeatureEntityVersionProperties(msrest.serialization.Model): + """FeatureEntityVersionProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar feature_entity_name: Required. + :vartype feature_entity_name: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "feature_entity_name": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "feature_entity_name": {"key": "featureEntityName", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, feature_entity_name: str, creation_context: "CreationContext", **kwargs): + """ + :keyword feature_entity_name: Required. + :paramtype feature_entity_name: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(FeatureEntityVersionProperties, self).__init__(**kwargs) + self.feature_entity_name = feature_entity_name + self.creation_context = creation_context + + +class FeaturesetSpecification(msrest.serialization.Model): + """FeaturesetSpecification. + + All required parameters must be populated in order to send to Azure. + + :ivar path: Required. + :vartype path: str + """ + + _validation = { + "path": {"required": True}, + } + + _attribute_map = { + "path": {"key": "path", "type": "str"}, + } + + def __init__(self, *, path: str, **kwargs): + """ + :keyword path: Required. + :paramtype path: str + """ + super(FeaturesetSpecification, self).__init__(**kwargs) + self.path = path + + +class FeaturesetsVersionedEntitiesResponse(msrest.serialization.Model): + """FeaturesetsVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.FeaturesetsVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[FeaturesetsVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["FeaturesetsVersionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.FeaturesetsVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(FeaturesetsVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class FeaturesetsVersionedEntity(msrest.serialization.Model): + """FeaturesetsVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.FeaturesetsVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.FeatureSetVersionAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.FeatureSetVersionProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "FeatureSetVersionAnnotations"}, + "properties": {"key": "properties", "type": "FeatureSetVersionProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "FeaturesetsVersionedEntityKind"], + annotations: "FeatureSetVersionAnnotations", + properties: "FeatureSetVersionProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.FeaturesetsVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.FeatureSetVersionAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.FeatureSetVersionProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(FeaturesetsVersionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class FeatureSetVersionAnnotations(msrest.serialization.Model): + """FeatureSetVersionAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar actual_name: Required. + :vartype actual_name: str + :ivar specification: Required. + :vartype specification: ~index_service_apis.models.FeaturesetSpecification + :ivar entities: Required. + :vartype entities: list[str] + :ivar features: Required. + :vartype features: list[~index_service_apis.models.Feature] + :ivar stage: Required. + :vartype stage: str + :ivar materialization_settings: Required. + :vartype materialization_settings: ~index_service_apis.models.MaterializationSettings + :ivar source: Required. + :vartype source: ~index_service_apis.models.FeatureSourceDto + :ivar feature_transformation_code: Required. + :vartype feature_transformation_code: ~index_service_apis.models.FeatureTransformationDto + :ivar temporal_join_lookback: Required. + :vartype temporal_join_lookback: ~index_service_apis.models.TimeDeltaDto + :ivar source_lookback: Required. + :vartype source_lookback: ~index_service_apis.models.TimeDeltaDto + :ivar timestamp_column: Required. + :vartype timestamp_column: ~index_service_apis.models.TimestampColumnDto + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "actual_name": {"required": True}, + "specification": {"required": True}, + "entities": {"required": True}, + "features": {"required": True}, + "stage": {"required": True}, + "materialization_settings": {"required": True}, + "source": {"required": True}, + "feature_transformation_code": {"required": True}, + "temporal_join_lookback": {"required": True}, + "source_lookback": {"required": True}, + "timestamp_column": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "actual_name": {"key": "actualName", "type": "str"}, + "specification": {"key": "specification", "type": "FeaturesetSpecification"}, + "entities": {"key": "entities", "type": "[str]"}, + "features": {"key": "features", "type": "[Feature]"}, + "stage": {"key": "stage", "type": "str"}, + "materialization_settings": {"key": "materializationSettings", "type": "MaterializationSettings"}, + "source": {"key": "source", "type": "FeatureSourceDto"}, + "feature_transformation_code": {"key": "featureTransformationCode", "type": "FeatureTransformationDto"}, + "temporal_join_lookback": {"key": "temporalJoinLookback", "type": "TimeDeltaDto"}, + "source_lookback": {"key": "sourceLookback", "type": "TimeDeltaDto"}, + "timestamp_column": {"key": "timestampColumn", "type": "TimestampColumnDto"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + actual_name: str, + specification: "FeaturesetSpecification", + entities: List[str], + features: List["Feature"], + stage: str, + materialization_settings: "MaterializationSettings", + source: "FeatureSourceDto", + feature_transformation_code: "FeatureTransformationDto", + temporal_join_lookback: "TimeDeltaDto", + source_lookback: "TimeDeltaDto", + timestamp_column: "TimestampColumnDto", + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword actual_name: Required. + :paramtype actual_name: str + :keyword specification: Required. + :paramtype specification: ~index_service_apis.models.FeaturesetSpecification + :keyword entities: Required. + :paramtype entities: list[str] + :keyword features: Required. + :paramtype features: list[~index_service_apis.models.Feature] + :keyword stage: Required. + :paramtype stage: str + :keyword materialization_settings: Required. + :paramtype materialization_settings: ~index_service_apis.models.MaterializationSettings + :keyword source: Required. + :paramtype source: ~index_service_apis.models.FeatureSourceDto + :keyword feature_transformation_code: Required. + :paramtype feature_transformation_code: ~index_service_apis.models.FeatureTransformationDto + :keyword temporal_join_lookback: Required. + :paramtype temporal_join_lookback: ~index_service_apis.models.TimeDeltaDto + :keyword source_lookback: Required. + :paramtype source_lookback: ~index_service_apis.models.TimeDeltaDto + :keyword timestamp_column: Required. + :paramtype timestamp_column: ~index_service_apis.models.TimestampColumnDto + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(FeatureSetVersionAnnotations, self).__init__(**kwargs) + self.actual_name = actual_name + self.specification = specification + self.entities = entities + self.features = features + self.stage = stage + self.materialization_settings = materialization_settings + self.source = source + self.feature_transformation_code = feature_transformation_code + self.temporal_join_lookback = temporal_join_lookback + self.source_lookback = source_lookback + self.timestamp_column = timestamp_column + self.description = description + self.archived = archived + self.tags = tags + + +class FeatureSetVersionProperties(msrest.serialization.Model): + """FeatureSetVersionProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar feature_set_name: Required. + :vartype feature_set_name: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "feature_set_name": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "feature_set_name": {"key": "featureSetName", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, feature_set_name: str, creation_context: "CreationContext", **kwargs): + """ + :keyword feature_set_name: Required. + :paramtype feature_set_name: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(FeatureSetVersionProperties, self).__init__(**kwargs) + self.feature_set_name = feature_set_name + self.creation_context = creation_context + + +class FeatureSourceDto(msrest.serialization.Model): + """FeatureSourceDto. + + All required parameters must be populated in order to send to Azure. + + :ivar type: Required. Possible values include: "mltable", "csv", "parquet". + :vartype type: str or ~index_service_apis.models.FeatureSourceDtoType + :ivar path: Required. + :vartype path: str + :ivar timestamp_column: Required. + :vartype timestamp_column: ~index_service_apis.models.TimestampColumnDto + :ivar source_delay: Required. + :vartype source_delay: ~index_service_apis.models.TimeDeltaDto + """ + + _validation = { + "type": {"required": True}, + "path": {"required": True}, + "timestamp_column": {"required": True}, + "source_delay": {"required": True}, + } + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "path": {"key": "path", "type": "str"}, + "timestamp_column": {"key": "timestampColumn", "type": "TimestampColumnDto"}, + "source_delay": {"key": "sourceDelay", "type": "TimeDeltaDto"}, + } + + def __init__( + self, + *, + type: Union[str, "FeatureSourceDtoType"], + path: str, + timestamp_column: "TimestampColumnDto", + source_delay: "TimeDeltaDto", + **kwargs + ): + """ + :keyword type: Required. Possible values include: "mltable", "csv", "parquet". + :paramtype type: str or ~index_service_apis.models.FeatureSourceDtoType + :keyword path: Required. + :paramtype path: str + :keyword timestamp_column: Required. + :paramtype timestamp_column: ~index_service_apis.models.TimestampColumnDto + :keyword source_delay: Required. + :paramtype source_delay: ~index_service_apis.models.TimeDeltaDto + """ + super(FeatureSourceDto, self).__init__(**kwargs) + self.type = type + self.path = path + self.timestamp_column = timestamp_column + self.source_delay = source_delay + + +class FeaturestoreentitiesVersionedEntitiesResponse(msrest.serialization.Model): + """FeaturestoreentitiesVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.FeaturestoreentitiesVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[FeaturestoreentitiesVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["FeaturestoreentitiesVersionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.FeaturestoreentitiesVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(FeaturestoreentitiesVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class FeaturestoreentitiesVersionedEntity(msrest.serialization.Model): + """FeaturestoreentitiesVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.FeaturestoreentitiesVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.FeatureEntityVersionProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "FeatureEntityVersionAnnotations"}, + "properties": {"key": "properties", "type": "FeatureEntityVersionProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "FeaturestoreentitiesVersionedEntityKind"], + annotations: "FeatureEntityVersionAnnotations", + properties: "FeatureEntityVersionProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.FeaturestoreentitiesVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.FeatureEntityVersionAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.FeatureEntityVersionProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(FeaturestoreentitiesVersionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class FeatureTransformationDto(msrest.serialization.Model): + """FeatureTransformationDto. + + All required parameters must be populated in order to send to Azure. + + :ivar path: Required. + :vartype path: str + :ivar transformer_class: Required. + :vartype transformer_class: str + """ + + _validation = { + "path": {"required": True}, + "transformer_class": {"required": True}, + } + + _attribute_map = { + "path": {"key": "path", "type": "str"}, + "transformer_class": {"key": "transformerClass", "type": "str"}, + } + + def __init__(self, *, path: str, transformer_class: str, **kwargs): + """ + :keyword path: Required. + :paramtype path: str + :keyword transformer_class: Required. + :paramtype transformer_class: str + """ + super(FeatureTransformationDto, self).__init__(**kwargs) + self.path = path + self.transformer_class = transformer_class + + +class FreeTextSearchColumn(msrest.serialization.Model): + """FreeTextSearchColumn. + + :ivar name: + :vartype name: str + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + } + + def __init__(self, *, name: Optional[str] = None, **kwargs): + """ + :keyword name: + :paramtype name: str + """ + super(FreeTextSearchColumn, self).__init__(**kwargs) + self.name = name + + +class GenericTriggerAnnotations(msrest.serialization.Model): + """GenericTriggerAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar display_name: Required. + :vartype display_name: str + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar provisioning_status: Required. Possible values include: "Completed", "Provisioning", + "Failed". + :vartype provisioning_status: str or + ~index_service_apis.models.GenericTriggerAnnotationsProvisioningStatus + :ivar trigger_type: Required. Possible values include: "Schedule", "Once". + :vartype trigger_type: str or ~index_service_apis.models.GenericTriggerAnnotationsTriggerType + :ivar schedule_method: Required. Possible values include: "Cron", "Recurrence". + :vartype schedule_method: str or + ~index_service_apis.models.GenericTriggerAnnotationsScheduleMethod + :ivar schedule_action_type: Required. Possible values include: "CreateJob", "InvokeEndpoint", + "ImportData", "ModelMonitor". + :vartype schedule_action_type: str or + ~index_service_apis.models.GenericTriggerAnnotationsScheduleActionType + :ivar recurrence: Required. + :vartype recurrence: ~index_service_apis.models.RecurrenceTrigger + :ivar cron: Required. + :vartype cron: ~index_service_apis.models.CronTrigger + :ivar start_time: Required. + :vartype start_time: str + :ivar end_time: Required. + :vartype end_time: str + :ivar time_zone: Required. + :vartype time_zone: str + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.GenericTriggerAnnotationsEntityStatus + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar last_updated_by: Required. + :vartype last_updated_by: ~index_service_apis.models.CreatedBy + :ivar definition: Required. + :vartype definition: str + :ivar feature_definition: Required. + :vartype feature_definition: str + :ivar managed_type: Required. Possible values include: "Customer", "System". + :vartype managed_type: str or ~index_service_apis.models.GenericTriggerAnnotationsManagedType + :ivar scenario_name: Required. + :vartype scenario_name: str + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "display_name": {"required": True}, + "kv_tags": {"required": True}, + "properties": {"required": True}, + "provisioning_status": {"required": True}, + "trigger_type": {"required": True}, + "schedule_method": {"required": True}, + "schedule_action_type": {"required": True}, + "recurrence": {"required": True}, + "cron": {"required": True}, + "start_time": {"required": True}, + "end_time": {"required": True}, + "time_zone": {"required": True}, + "entity_status": {"required": True}, + "last_modified_date": {"required": True}, + "last_updated_by": {"required": True}, + "definition": {"required": True}, + "feature_definition": {"required": True}, + "managed_type": {"required": True}, + "scenario_name": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "display_name": {"key": "displayName", "type": "str"}, + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "provisioning_status": {"key": "provisioningStatus", "type": "str"}, + "trigger_type": {"key": "triggerType", "type": "str"}, + "schedule_method": {"key": "scheduleMethod", "type": "str"}, + "schedule_action_type": {"key": "scheduleActionType", "type": "str"}, + "recurrence": {"key": "recurrence", "type": "RecurrenceTrigger"}, + "cron": {"key": "cron", "type": "CronTrigger"}, + "start_time": {"key": "startTime", "type": "str"}, + "end_time": {"key": "endTime", "type": "str"}, + "time_zone": {"key": "timeZone", "type": "str"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"}, + "definition": {"key": "definition", "type": "str"}, + "feature_definition": {"key": "featureDefinition", "type": "str"}, + "managed_type": {"key": "managedType", "type": "str"}, + "scenario_name": {"key": "scenarioName", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + display_name: str, + kv_tags: Dict[str, str], + properties: Dict[str, str], + provisioning_status: Union[str, "GenericTriggerAnnotationsProvisioningStatus"], + trigger_type: Union[str, "GenericTriggerAnnotationsTriggerType"], + schedule_method: Union[str, "GenericTriggerAnnotationsScheduleMethod"], + schedule_action_type: Union[str, "GenericTriggerAnnotationsScheduleActionType"], + recurrence: "RecurrenceTrigger", + cron: "CronTrigger", + start_time: str, + end_time: str, + time_zone: str, + entity_status: Union[str, "GenericTriggerAnnotationsEntityStatus"], + last_modified_date: datetime.datetime, + last_updated_by: "CreatedBy", + definition: str, + feature_definition: str, + managed_type: Union[str, "GenericTriggerAnnotationsManagedType"], + scenario_name: str, + name: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword display_name: Required. + :paramtype display_name: str + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword provisioning_status: Required. Possible values include: "Completed", "Provisioning", + "Failed". + :paramtype provisioning_status: str or + ~index_service_apis.models.GenericTriggerAnnotationsProvisioningStatus + :keyword trigger_type: Required. Possible values include: "Schedule", "Once". + :paramtype trigger_type: str or ~index_service_apis.models.GenericTriggerAnnotationsTriggerType + :keyword schedule_method: Required. Possible values include: "Cron", "Recurrence". + :paramtype schedule_method: str or + ~index_service_apis.models.GenericTriggerAnnotationsScheduleMethod + :keyword schedule_action_type: Required. Possible values include: "CreateJob", + "InvokeEndpoint", "ImportData", "ModelMonitor". + :paramtype schedule_action_type: str or + ~index_service_apis.models.GenericTriggerAnnotationsScheduleActionType + :keyword recurrence: Required. + :paramtype recurrence: ~index_service_apis.models.RecurrenceTrigger + :keyword cron: Required. + :paramtype cron: ~index_service_apis.models.CronTrigger + :keyword start_time: Required. + :paramtype start_time: str + :keyword end_time: Required. + :paramtype end_time: str + :keyword time_zone: Required. + :paramtype time_zone: str + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or + ~index_service_apis.models.GenericTriggerAnnotationsEntityStatus + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword last_updated_by: Required. + :paramtype last_updated_by: ~index_service_apis.models.CreatedBy + :keyword definition: Required. + :paramtype definition: str + :keyword feature_definition: Required. + :paramtype feature_definition: str + :keyword managed_type: Required. Possible values include: "Customer", "System". + :paramtype managed_type: str or ~index_service_apis.models.GenericTriggerAnnotationsManagedType + :keyword scenario_name: Required. + :paramtype scenario_name: str + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(GenericTriggerAnnotations, self).__init__(**kwargs) + self.display_name = display_name + self.kv_tags = kv_tags + self.properties = properties + self.provisioning_status = provisioning_status + self.trigger_type = trigger_type + self.schedule_method = schedule_method + self.schedule_action_type = schedule_action_type + self.recurrence = recurrence + self.cron = cron + self.start_time = start_time + self.end_time = end_time + self.time_zone = time_zone + self.entity_status = entity_status + self.last_modified_date = last_modified_date + self.last_updated_by = last_updated_by + self.definition = definition + self.feature_definition = feature_definition + self.managed_type = managed_type + self.scenario_name = scenario_name + self.name = name + self.description = description + self.archived = archived + self.tags = tags + + +class GenericTriggerProperties(msrest.serialization.Model): + """GenericTriggerProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(GenericTriggerProperties, self).__init__(**kwargs) + self.id = id + self.creation_context = creation_context + + +class GenerictriggersUnversionedEntitiesResponse(msrest.serialization.Model): + """GenerictriggersUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.GenerictriggersUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[GenerictriggersUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["GenerictriggersUnversionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.GenerictriggersUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(GenerictriggersUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class GenerictriggersUnversionedEntity(msrest.serialization.Model): + """GenerictriggersUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.GenerictriggersUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.GenericTriggerAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.GenericTriggerProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "GenericTriggerAnnotations"}, + "properties": {"key": "properties", "type": "GenericTriggerProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "GenerictriggersUnversionedEntityKind"], + annotations: "GenericTriggerAnnotations", + properties: "GenericTriggerProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.GenerictriggersUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.GenericTriggerAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.GenericTriggerProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(GenerictriggersUnversionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class HighlightOptions(msrest.serialization.Model): + """HighlightOptions. + + :ivar pre_tag: + :vartype pre_tag: str + :ivar post_tag: + :vartype post_tag: str + :ivar fields: + :vartype fields: list[str] + """ + + _attribute_map = { + "pre_tag": {"key": "preTag", "type": "str"}, + "post_tag": {"key": "postTag", "type": "str"}, + "fields": {"key": "fields", "type": "[str]"}, + } + + def __init__( + self, + *, + pre_tag: Optional[str] = None, + post_tag: Optional[str] = None, + fields: Optional[List[str]] = None, + **kwargs + ): + """ + :keyword pre_tag: + :paramtype pre_tag: str + :keyword post_tag: + :paramtype post_tag: str + :keyword fields: + :paramtype fields: list[str] + """ + super(HighlightOptions, self).__init__(**kwargs) + self.pre_tag = pre_tag + self.post_tag = post_tag + self.fields = fields + + +class IndependentPipelineAnnotations(msrest.serialization.Model): + """IndependentPipelineAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar url: Required. + :vartype url: str + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar step_tags: Required. Dictionary of :code:`<string>`. + :vartype step_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar step_properties: Required. Dictionary of :code:`<string>`. + :vartype step_properties: dict[str, str] + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or + ~index_service_apis.models.IndependentPipelineAnnotationsEntityStatus + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar last_updated_by: Required. + :vartype last_updated_by: ~index_service_apis.models.CreatedBy + :ivar last_run_id: Required. + :vartype last_run_id: str + :ivar pipeline_type: Required. + :vartype pipeline_type: str + :ivar last_run_status_code: Required. Possible values include: "NotStarted", "Running", + "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested". + :vartype last_run_status_code: str or + ~index_service_apis.models.IndependentPipelineAnnotationsLastRunStatusCode + :ivar last_run_creation_time: Required. + :vartype last_run_creation_time: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "url": {"required": True}, + "kv_tags": {"required": True}, + "step_tags": {"required": True}, + "properties": {"required": True}, + "step_properties": {"required": True}, + "entity_status": {"required": True}, + "last_modified_date": {"required": True}, + "last_updated_by": {"required": True}, + "last_run_id": {"required": True}, + "pipeline_type": {"required": True}, + "last_run_status_code": {"required": True}, + "last_run_creation_time": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "url": {"key": "url", "type": "str"}, + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "step_tags": {"key": "stepTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "step_properties": {"key": "stepProperties", "type": "{str}"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"}, + "last_run_id": {"key": "lastRunId", "type": "str"}, + "pipeline_type": {"key": "pipelineType", "type": "str"}, + "last_run_status_code": {"key": "lastRunStatusCode", "type": "str"}, + "last_run_creation_time": {"key": "lastRunCreationTime", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + url: str, + kv_tags: Dict[str, str], + step_tags: Dict[str, str], + properties: Dict[str, str], + step_properties: Dict[str, str], + entity_status: Union[str, "IndependentPipelineAnnotationsEntityStatus"], + last_modified_date: datetime.datetime, + last_updated_by: "CreatedBy", + last_run_id: str, + pipeline_type: str, + last_run_status_code: Union[str, "IndependentPipelineAnnotationsLastRunStatusCode"], + last_run_creation_time: datetime.datetime, + name: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword url: Required. + :paramtype url: str + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword step_tags: Required. Dictionary of :code:`<string>`. + :paramtype step_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword step_properties: Required. Dictionary of :code:`<string>`. + :paramtype step_properties: dict[str, str] + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or + ~index_service_apis.models.IndependentPipelineAnnotationsEntityStatus + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword last_updated_by: Required. + :paramtype last_updated_by: ~index_service_apis.models.CreatedBy + :keyword last_run_id: Required. + :paramtype last_run_id: str + :keyword pipeline_type: Required. + :paramtype pipeline_type: str + :keyword last_run_status_code: Required. Possible values include: "NotStarted", "Running", + "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested". + :paramtype last_run_status_code: str or + ~index_service_apis.models.IndependentPipelineAnnotationsLastRunStatusCode + :keyword last_run_creation_time: Required. + :paramtype last_run_creation_time: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(IndependentPipelineAnnotations, self).__init__(**kwargs) + self.url = url + self.kv_tags = kv_tags + self.step_tags = step_tags + self.properties = properties + self.step_properties = step_properties + self.entity_status = entity_status + self.last_modified_date = last_modified_date + self.last_updated_by = last_updated_by + self.last_run_id = last_run_id + self.pipeline_type = pipeline_type + self.last_run_status_code = last_run_status_code + self.last_run_creation_time = last_run_creation_time + self.name = name + self.description = description + self.archived = archived + self.tags = tags + + +class IndependentPipelineProperties(msrest.serialization.Model): + """IndependentPipelineProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(IndependentPipelineProperties, self).__init__(**kwargs) + self.id = id + self.creation_context = creation_context + + +class IndependentpipelinesUnversionedEntitiesResponse(msrest.serialization.Model): + """IndependentpipelinesUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.IndependentpipelinesUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[IndependentpipelinesUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["IndependentpipelinesUnversionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.IndependentpipelinesUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(IndependentpipelinesUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class IndependentpipelinesUnversionedEntity(msrest.serialization.Model): + """IndependentpipelinesUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.IndependentpipelinesUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.IndependentPipelineAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.IndependentPipelineProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "IndependentPipelineAnnotations"}, + "properties": {"key": "properties", "type": "IndependentPipelineProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "IndependentpipelinesUnversionedEntityKind"], + annotations: "IndependentPipelineAnnotations", + properties: "IndependentPipelineProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.IndependentpipelinesUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.IndependentPipelineAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.IndependentPipelineProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(IndependentpipelinesUnversionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class IndexAnnotations(msrest.serialization.Model): + """IndexAnnotations. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar archived: + :vartype archived: bool + :ivar tags: A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + additional_properties: Optional[Dict[str, Any]] = None, + archived: Optional[bool] = None, + tags: Optional[Dict[str, str]] = None, + **kwargs + ): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword archived: + :paramtype archived: bool + :keyword tags: A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(IndexAnnotations, self).__init__(**kwargs) + self.additional_properties = additional_properties + self.archived = archived + self.tags = tags + + +class IndexColumn(msrest.serialization.Model): + """IndexColumn. + + All required parameters must be populated in order to send to Azure. + + :ivar data_type: Required. Possible values include: "String", "Integer", "Long", "Float", + "Double", "Binary", "Datetime", "Boolean". + :vartype data_type: str or ~index_service_apis.models.IndexColumnDataType + :ivar column_name: Required. + :vartype column_name: str + """ + + _validation = { + "data_type": {"required": True}, + "column_name": {"required": True}, + } + + _attribute_map = { + "data_type": {"key": "dataType", "type": "str"}, + "column_name": {"key": "columnName", "type": "str"}, + } + + def __init__(self, *, data_type: Union[str, "IndexColumnDataType"], column_name: str, **kwargs): + """ + :keyword data_type: Required. Possible values include: "String", "Integer", "Long", "Float", + "Double", "Binary", "Datetime", "Boolean". + :paramtype data_type: str or ~index_service_apis.models.IndexColumnDataType + :keyword column_name: Required. + :paramtype column_name: str + """ + super(IndexColumn, self).__init__(**kwargs) + self.data_type = data_type + self.column_name = column_name + + +class IndexColumnDto(msrest.serialization.Model): + """IndexColumnDto. + + All required parameters must be populated in order to send to Azure. + + :ivar type: Required. Possible values include: "string", "integer", "long", "float", "double", + "binary", "datetime", "boolean". + :vartype type: str or ~index_service_apis.models.IndexColumnDtoType + :ivar name: Required. + :vartype name: str + """ + + _validation = { + "type": {"required": True}, + "name": {"required": True}, + } + + _attribute_map = { + "type": {"key": "type", "type": "str"}, + "name": {"key": "name", "type": "str"}, + } + + def __init__(self, *, type: Union[str, "IndexColumnDtoType"], name: str, **kwargs): + """ + :keyword type: Required. Possible values include: "string", "integer", "long", "float", + "double", "binary", "datetime", "boolean". + :paramtype type: str or ~index_service_apis.models.IndexColumnDtoType + :keyword name: Required. + :paramtype name: str + """ + super(IndexColumnDto, self).__init__(**kwargs) + self.type = type + self.name = name + + +class IndexedErrorResponse(msrest.serialization.Model): + """IndexedErrorResponse. + + All required parameters must be populated in order to send to Azure. + + :ivar code: Required. + :vartype code: str + :ivar error_code_hierarchy: Required. + :vartype error_code_hierarchy: str + :ivar message: Required. + :vartype message: str + :ivar time: Required. + :vartype time: ~datetime.datetime + :ivar component_name: Required. + :vartype component_name: str + :ivar severity: Required. + :vartype severity: int + :ivar details_uri: Required. + :vartype details_uri: str + :ivar reference_code: Required. + :vartype reference_code: str + """ + + _validation = { + "code": {"required": True}, + "error_code_hierarchy": {"required": True}, + "message": {"required": True}, + "time": {"required": True}, + "component_name": {"required": True}, + "severity": {"required": True}, + "details_uri": {"required": True}, + "reference_code": {"required": True}, + } + + _attribute_map = { + "code": {"key": "code", "type": "str"}, + "error_code_hierarchy": {"key": "errorCodeHierarchy", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "time": {"key": "time", "type": "iso-8601"}, + "component_name": {"key": "componentName", "type": "str"}, + "severity": {"key": "severity", "type": "int"}, + "details_uri": {"key": "detailsUri", "type": "str"}, + "reference_code": {"key": "referenceCode", "type": "str"}, + } + + def __init__( + self, + *, + code: str, + error_code_hierarchy: str, + message: str, + time: datetime.datetime, + component_name: str, + severity: int, + details_uri: str, + reference_code: str, + **kwargs + ): + """ + :keyword code: Required. + :paramtype code: str + :keyword error_code_hierarchy: Required. + :paramtype error_code_hierarchy: str + :keyword message: Required. + :paramtype message: str + :keyword time: Required. + :paramtype time: ~datetime.datetime + :keyword component_name: Required. + :paramtype component_name: str + :keyword severity: Required. + :paramtype severity: int + :keyword details_uri: Required. + :paramtype details_uri: str + :keyword reference_code: Required. + :paramtype reference_code: str + """ + super(IndexedErrorResponse, self).__init__(**kwargs) + self.code = code + self.error_code_hierarchy = error_code_hierarchy + self.message = message + self.time = time + self.component_name = component_name + self.severity = severity + self.details_uri = details_uri + self.reference_code = reference_code + + +class IndexEntitiesLocalOperationRequest(msrest.serialization.Model): + """IndexEntitiesLocalOperationRequest. + + :ivar get_all_entities: + :vartype get_all_entities: bool + :ivar group: + :vartype group: list[~index_service_apis.models.IndexEntitiesRequestGroup] + :ivar highlight_options: + :vartype highlight_options: ~index_service_apis.models.HighlightOptions + :ivar search_builder: + :vartype search_builder: str + :ivar search_mode: + :vartype search_mode: str + :ivar free_text_search: + :vartype free_text_search: str + :ivar free_text_search_columns: + :vartype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn] + :ivar filters: + :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar asset_resource_filters: + :vartype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar order: + :vartype order: list[~index_service_apis.models.IndexEntitiesRequestOrder] + :ivar page_size: + :vartype page_size: int + :ivar skip: + :vartype skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar include_total_result_count: + :vartype include_total_result_count: bool + :ivar resources: + :vartype resources: list[~index_service_apis.models.ResourceInformation] + :ivar cmk_fanout: + :vartype cmk_fanout: bool + :ivar include_fanout_data: + :vartype include_fanout_data: bool + :ivar shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData] + """ + + _attribute_map = { + "get_all_entities": {"key": "getAllEntities", "type": "bool"}, + "group": {"key": "group", "type": "[IndexEntitiesRequestGroup]"}, + "highlight_options": {"key": "highlightOptions", "type": "HighlightOptions"}, + "search_builder": {"key": "searchBuilder", "type": "str"}, + "search_mode": {"key": "searchMode", "type": "str"}, + "free_text_search": {"key": "freeTextSearch", "type": "str"}, + "free_text_search_columns": {"key": "freeTextSearchColumns", "type": "[FreeTextSearchColumn]"}, + "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"}, + "asset_resource_filters": {"key": "assetResourceFilters", "type": "[IndexEntitiesRequestFilter]"}, + "order": {"key": "order", "type": "[IndexEntitiesRequestOrder]"}, + "page_size": {"key": "pageSize", "type": "int"}, + "skip": {"key": "skip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "include_total_result_count": {"key": "includeTotalResultCount", "type": "bool"}, + "resources": {"key": "resources", "type": "[ResourceInformation]"}, + "cmk_fanout": {"key": "cmkFanout", "type": "bool"}, + "include_fanout_data": {"key": "includeFanoutData", "type": "bool"}, + "shard_id_to_shard_skips": {"key": "shardIdToShardSkips", "type": "{SingleShardFanoutData}"}, + } + + def __init__( + self, + *, + get_all_entities: Optional[bool] = None, + group: Optional[List["IndexEntitiesRequestGroup"]] = None, + highlight_options: Optional["HighlightOptions"] = None, + search_builder: Optional[str] = None, + search_mode: Optional[str] = None, + free_text_search: Optional[str] = None, + free_text_search_columns: Optional[List["FreeTextSearchColumn"]] = None, + filters: Optional[List["IndexEntitiesRequestFilter"]] = None, + asset_resource_filters: Optional[List["IndexEntitiesRequestFilter"]] = None, + order: Optional[List["IndexEntitiesRequestOrder"]] = None, + page_size: Optional[int] = None, + skip: Optional[int] = None, + continuation_token: Optional[str] = None, + include_total_result_count: Optional[bool] = None, + resources: Optional[List["ResourceInformation"]] = None, + cmk_fanout: Optional[bool] = None, + include_fanout_data: Optional[bool] = None, + shard_id_to_shard_skips: Optional[Dict[str, "SingleShardFanoutData"]] = None, + **kwargs + ): + """ + :keyword get_all_entities: + :paramtype get_all_entities: bool + :keyword group: + :paramtype group: list[~index_service_apis.models.IndexEntitiesRequestGroup] + :keyword highlight_options: + :paramtype highlight_options: ~index_service_apis.models.HighlightOptions + :keyword search_builder: + :paramtype search_builder: str + :keyword search_mode: + :paramtype search_mode: str + :keyword free_text_search: + :paramtype free_text_search: str + :keyword free_text_search_columns: + :paramtype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn] + :keyword filters: + :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword asset_resource_filters: + :paramtype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword order: + :paramtype order: list[~index_service_apis.models.IndexEntitiesRequestOrder] + :keyword page_size: + :paramtype page_size: int + :keyword skip: + :paramtype skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword include_total_result_count: + :paramtype include_total_result_count: bool + :keyword resources: + :paramtype resources: list[~index_service_apis.models.ResourceInformation] + :keyword cmk_fanout: + :paramtype cmk_fanout: bool + :keyword include_fanout_data: + :paramtype include_fanout_data: bool + :keyword shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData] + """ + super(IndexEntitiesLocalOperationRequest, self).__init__(**kwargs) + self.get_all_entities = get_all_entities + self.group = group + self.highlight_options = highlight_options + self.search_builder = search_builder + self.search_mode = search_mode + self.free_text_search = free_text_search + self.free_text_search_columns = free_text_search_columns + self.filters = filters + self.asset_resource_filters = asset_resource_filters + self.order = order + self.page_size = page_size + self.skip = skip + self.continuation_token = continuation_token + self.include_total_result_count = include_total_result_count + self.resources = resources + self.cmk_fanout = cmk_fanout + self.include_fanout_data = include_fanout_data + self.shard_id_to_shard_skips = shard_id_to_shard_skips + + +class IndexEntitiesRequest(msrest.serialization.Model): + """IndexEntitiesRequest. + + :ivar highlight_options: + :vartype highlight_options: ~index_service_apis.models.HighlightOptions + :ivar search_builder: + :vartype search_builder: str + :ivar search_mode: + :vartype search_mode: str + :ivar free_text_search: + :vartype free_text_search: str + :ivar free_text_search_columns: + :vartype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn] + :ivar filters: + :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar asset_resource_filters: + :vartype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar order: + :vartype order: list[~index_service_apis.models.IndexEntitiesRequestOrder] + :ivar page_size: + :vartype page_size: int + :ivar skip: + :vartype skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar include_total_result_count: + :vartype include_total_result_count: bool + :ivar resources: + :vartype resources: list[~index_service_apis.models.ResourceInformation] + :ivar cmk_fanout: + :vartype cmk_fanout: bool + :ivar include_fanout_data: + :vartype include_fanout_data: bool + :ivar shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData] + """ + + _attribute_map = { + "highlight_options": {"key": "highlightOptions", "type": "HighlightOptions"}, + "search_builder": {"key": "searchBuilder", "type": "str"}, + "search_mode": {"key": "searchMode", "type": "str"}, + "free_text_search": {"key": "freeTextSearch", "type": "str"}, + "free_text_search_columns": {"key": "freeTextSearchColumns", "type": "[FreeTextSearchColumn]"}, + "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"}, + "asset_resource_filters": {"key": "assetResourceFilters", "type": "[IndexEntitiesRequestFilter]"}, + "order": {"key": "order", "type": "[IndexEntitiesRequestOrder]"}, + "page_size": {"key": "pageSize", "type": "int"}, + "skip": {"key": "skip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "include_total_result_count": {"key": "includeTotalResultCount", "type": "bool"}, + "resources": {"key": "resources", "type": "[ResourceInformation]"}, + "cmk_fanout": {"key": "cmkFanout", "type": "bool"}, + "include_fanout_data": {"key": "includeFanoutData", "type": "bool"}, + "shard_id_to_shard_skips": {"key": "shardIdToShardSkips", "type": "{SingleShardFanoutData}"}, + } + + def __init__( + self, + *, + highlight_options: Optional["HighlightOptions"] = None, + search_builder: Optional[str] = None, + search_mode: Optional[str] = None, + free_text_search: Optional[str] = None, + free_text_search_columns: Optional[List["FreeTextSearchColumn"]] = None, + filters: Optional[List["IndexEntitiesRequestFilter"]] = None, + asset_resource_filters: Optional[List["IndexEntitiesRequestFilter"]] = None, + order: Optional[List["IndexEntitiesRequestOrder"]] = None, + page_size: Optional[int] = None, + skip: Optional[int] = None, + continuation_token: Optional[str] = None, + include_total_result_count: Optional[bool] = None, + resources: Optional[List["ResourceInformation"]] = None, + cmk_fanout: Optional[bool] = None, + include_fanout_data: Optional[bool] = None, + shard_id_to_shard_skips: Optional[Dict[str, "SingleShardFanoutData"]] = None, + **kwargs + ): + """ + :keyword highlight_options: + :paramtype highlight_options: ~index_service_apis.models.HighlightOptions + :keyword search_builder: + :paramtype search_builder: str + :keyword search_mode: + :paramtype search_mode: str + :keyword free_text_search: + :paramtype free_text_search: str + :keyword free_text_search_columns: + :paramtype free_text_search_columns: list[~index_service_apis.models.FreeTextSearchColumn] + :keyword filters: + :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword asset_resource_filters: + :paramtype asset_resource_filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword order: + :paramtype order: list[~index_service_apis.models.IndexEntitiesRequestOrder] + :keyword page_size: + :paramtype page_size: int + :keyword skip: + :paramtype skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword include_total_result_count: + :paramtype include_total_result_count: bool + :keyword resources: + :paramtype resources: list[~index_service_apis.models.ResourceInformation] + :keyword cmk_fanout: + :paramtype cmk_fanout: bool + :keyword include_fanout_data: + :paramtype include_fanout_data: bool + :keyword shard_id_to_shard_skips: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype shard_id_to_shard_skips: dict[str, ~index_service_apis.models.SingleShardFanoutData] + """ + super(IndexEntitiesRequest, self).__init__(**kwargs) + self.highlight_options = highlight_options + self.search_builder = search_builder + self.search_mode = search_mode + self.free_text_search = free_text_search + self.free_text_search_columns = free_text_search_columns + self.filters = filters + self.asset_resource_filters = asset_resource_filters + self.order = order + self.page_size = page_size + self.skip = skip + self.continuation_token = continuation_token + self.include_total_result_count = include_total_result_count + self.resources = resources + self.cmk_fanout = cmk_fanout + self.include_fanout_data = include_fanout_data + self.shard_id_to_shard_skips = shard_id_to_shard_skips + + +class IndexEntitiesRequestFilter(msrest.serialization.Model): + """IndexEntitiesRequestFilter. + + :ivar field: + :vartype field: str + :ivar operator: + :vartype operator: str + :ivar values: + :vartype values: list[str] + """ + + _attribute_map = { + "field": {"key": "field", "type": "str"}, + "operator": {"key": "operator", "type": "str"}, + "values": {"key": "values", "type": "[str]"}, + } + + def __init__( + self, + *, + field: Optional[str] = None, + operator: Optional[str] = None, + values: Optional[List[str]] = None, + **kwargs + ): + """ + :keyword field: + :paramtype field: str + :keyword operator: + :paramtype operator: str + :keyword values: + :paramtype values: list[str] + """ + super(IndexEntitiesRequestFilter, self).__init__(**kwargs) + self.field = field + self.operator = operator + self.values = values + + +class IndexEntitiesRequestGroup(msrest.serialization.Model): + """IndexEntitiesRequestGroup. + + :ivar field: + :vartype field: str + """ + + _attribute_map = { + "field": {"key": "field", "type": "str"}, + } + + def __init__(self, *, field: Optional[str] = None, **kwargs): + """ + :keyword field: + :paramtype field: str + """ + super(IndexEntitiesRequestGroup, self).__init__(**kwargs) + self.field = field + + +class IndexEntitiesRequestOrder(msrest.serialization.Model): + """IndexEntitiesRequestOrder. + + :ivar field: + :vartype field: str + :ivar direction: Possible values include: "Asc", "Desc". + :vartype direction: str or ~index_service_apis.models.IndexEntitiesRequestOrderDirection + """ + + _attribute_map = { + "field": {"key": "field", "type": "str"}, + "direction": {"key": "direction", "type": "str"}, + } + + def __init__( + self, + *, + field: Optional[str] = None, + direction: Optional[Union[str, "IndexEntitiesRequestOrderDirection"]] = None, + **kwargs + ): + """ + :keyword field: + :paramtype field: str + :keyword direction: Possible values include: "Asc", "Desc". + :paramtype direction: str or ~index_service_apis.models.IndexEntitiesRequestOrderDirection + """ + super(IndexEntitiesRequestOrder, self).__init__(**kwargs) + self.field = field + self.direction = direction + + +class IndexEntitiesResponse(msrest.serialization.Model): + """IndexEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.IndexEntityResponse] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[IndexEntityResponse]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["IndexEntityResponse"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.IndexEntityResponse] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(IndexEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class IndexEntityContainerMetadata(msrest.serialization.Model): + """IndexEntityContainerMetadata. + + :ivar resource_id: + :vartype resource_id: str + :ivar subscription_id: + :vartype subscription_id: str + :ivar resource_group: + :vartype resource_group: str + :ivar resource_name: + :vartype resource_name: str + :ivar entity_container_type: + :vartype entity_container_type: str + :ivar regions: + :vartype regions: list[~index_service_apis.models.ResourceRegion] + :ivar tenant_id: + :vartype tenant_id: str + :ivar immutable_resource_id: + :vartype immutable_resource_id: str + :ivar is_public_resource: + :vartype is_public_resource: bool + """ + + _attribute_map = { + "resource_id": {"key": "resourceId", "type": "str"}, + "subscription_id": {"key": "subscriptionId", "type": "str"}, + "resource_group": {"key": "resourceGroup", "type": "str"}, + "resource_name": {"key": "resourceName", "type": "str"}, + "entity_container_type": {"key": "entityContainerType", "type": "str"}, + "regions": {"key": "regions", "type": "[ResourceRegion]"}, + "tenant_id": {"key": "tenantId", "type": "str"}, + "immutable_resource_id": {"key": "immutableResourceId", "type": "str"}, + "is_public_resource": {"key": "isPublicResource", "type": "bool"}, + } + + def __init__( + self, + *, + resource_id: Optional[str] = None, + subscription_id: Optional[str] = None, + resource_group: Optional[str] = None, + resource_name: Optional[str] = None, + entity_container_type: Optional[str] = None, + regions: Optional[List["ResourceRegion"]] = None, + tenant_id: Optional[str] = None, + immutable_resource_id: Optional[str] = None, + is_public_resource: Optional[bool] = None, + **kwargs + ): + """ + :keyword resource_id: + :paramtype resource_id: str + :keyword subscription_id: + :paramtype subscription_id: str + :keyword resource_group: + :paramtype resource_group: str + :keyword resource_name: + :paramtype resource_name: str + :keyword entity_container_type: + :paramtype entity_container_type: str + :keyword regions: + :paramtype regions: list[~index_service_apis.models.ResourceRegion] + :keyword tenant_id: + :paramtype tenant_id: str + :keyword immutable_resource_id: + :paramtype immutable_resource_id: str + :keyword is_public_resource: + :paramtype is_public_resource: bool + """ + super(IndexEntityContainerMetadata, self).__init__(**kwargs) + self.resource_id = resource_id + self.subscription_id = subscription_id + self.resource_group = resource_group + self.resource_name = resource_name + self.entity_container_type = entity_container_type + self.regions = regions + self.tenant_id = tenant_id + self.immutable_resource_id = immutable_resource_id + self.is_public_resource = is_public_resource + + +class IndexEntityResponse(msrest.serialization.Model): + """IndexEntityResponse. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar relevancy_score: + :vartype relevancy_score: float + :ivar entity_resource_name: + :vartype entity_resource_name: str + :ivar highlights: Dictionary of + <components·jiilq·schemas·indexentityresponse·properties·highlights·additionalproperties>. + :vartype highlights: dict[str, list[str]] + :ivar usage: + :vartype usage: ~index_service_apis.models.Usage + :ivar schema_id: + :vartype schema_id: str + :ivar entity_id: + :vartype entity_id: str + :ivar kind: Possible values include: "Invalid", "LineageRoot", "Versioned", "Unversioned". + :vartype kind: str or ~index_service_apis.models.EntityKind + :ivar annotations: + :vartype annotations: ~index_service_apis.models.IndexAnnotations + :ivar properties: + :vartype properties: ~index_service_apis.models.IndexProperties + :ivar internal: Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: + :vartype update_sequence: long + :ivar type: + :vartype type: str + :ivar version: + :vartype version: str + :ivar entity_container_id: + :vartype entity_container_id: str + :ivar entity_object_id: + :vartype entity_object_id: str + :ivar resource_type: + :vartype resource_type: str + :ivar relationships: + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "version": {"readonly": True}, + "entity_container_id": {"readonly": True}, + "entity_object_id": {"readonly": True}, + "resource_type": {"readonly": True}, + } + + _attribute_map = { + "relevancy_score": {"key": "relevancyScore", "type": "float"}, + "entity_resource_name": {"key": "entityResourceName", "type": "str"}, + "highlights": {"key": "highlights", "type": "{[str]}"}, + "usage": {"key": "usage", "type": "Usage"}, + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "IndexAnnotations"}, + "properties": {"key": "properties", "type": "IndexProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "long"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + relevancy_score: Optional[float] = None, + entity_resource_name: Optional[str] = None, + highlights: Optional[Dict[str, List[str]]] = None, + usage: Optional["Usage"] = None, + schema_id: Optional[str] = None, + entity_id: Optional[str] = None, + kind: Optional[Union[str, "EntityKind"]] = None, + annotations: Optional["IndexAnnotations"] = None, + properties: Optional["IndexProperties"] = None, + internal: Optional[Dict[str, Any]] = None, + update_sequence: Optional[int] = None, + type: Optional[str] = None, + relationships: Optional[List["Relationship"]] = None, + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword relevancy_score: + :paramtype relevancy_score: float + :keyword entity_resource_name: + :paramtype entity_resource_name: str + :keyword highlights: Dictionary of + <components·jiilq·schemas·indexentityresponse·properties·highlights·additionalproperties>. + :paramtype highlights: dict[str, list[str]] + :keyword usage: + :paramtype usage: ~index_service_apis.models.Usage + :keyword schema_id: + :paramtype schema_id: str + :keyword entity_id: + :paramtype entity_id: str + :keyword kind: Possible values include: "Invalid", "LineageRoot", "Versioned", "Unversioned". + :paramtype kind: str or ~index_service_apis.models.EntityKind + :keyword annotations: + :paramtype annotations: ~index_service_apis.models.IndexAnnotations + :keyword properties: + :paramtype properties: ~index_service_apis.models.IndexProperties + :keyword internal: Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: + :paramtype update_sequence: long + :keyword type: + :paramtype type: str + :keyword relationships: + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(IndexEntityResponse, self).__init__(**kwargs) + self.relevancy_score = relevancy_score + self.entity_resource_name = entity_resource_name + self.highlights = highlights + self.usage = usage + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = None + self.entity_container_id = None + self.entity_object_id = None + self.resource_type = None + self.relationships = relationships + self.asset_id = asset_id + + +class IndexProperties(msrest.serialization.Model): + """IndexProperties. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar updated_time: + :vartype updated_time: ~datetime.datetime + :ivar creation_context: + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "updated_time": {"key": "updatedTime", "type": "iso-8601"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__( + self, + *, + additional_properties: Optional[Dict[str, Any]] = None, + updated_time: Optional[datetime.datetime] = None, + creation_context: Optional["CreationContext"] = None, + **kwargs + ): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword updated_time: + :paramtype updated_time: ~datetime.datetime + :keyword creation_context: + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(IndexProperties, self).__init__(**kwargs) + self.additional_properties = additional_properties + self.updated_time = updated_time + self.creation_context = creation_context + + +class IndexResourceDiscoveryResponseItem(msrest.serialization.Model): + """IndexResourceDiscoveryResponseItem. + + :ivar name: + :vartype name: str + :ivar resource_id: + :vartype resource_id: str + :ivar resource_type: + :vartype resource_type: str + :ivar region: + :vartype region: str + :ivar regions: + :vartype regions: list[~index_service_apis.models.ResourceRegion] + :ivar subscription_id: + :vartype subscription_id: str + :ivar resource_group_name: + :vartype resource_group_name: str + :ivar tags: A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + :ivar is_customer_managed: + :vartype is_customer_managed: bool + :ivar is_private_link_resource: + :vartype is_private_link_resource: bool + :ivar is_private_link_resource_behind_vnet: + :vartype is_private_link_resource_behind_vnet: bool + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "region": {"key": "region", "type": "str"}, + "regions": {"key": "regions", "type": "[ResourceRegion]"}, + "subscription_id": {"key": "subscriptionId", "type": "str"}, + "resource_group_name": {"key": "resourceGroupName", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "is_customer_managed": {"key": "isCustomerManaged", "type": "bool"}, + "is_private_link_resource": {"key": "isPrivateLinkResource", "type": "bool"}, + "is_private_link_resource_behind_vnet": {"key": "isPrivateLinkResourceBehindVnet", "type": "bool"}, + } + + def __init__( + self, + *, + name: Optional[str] = None, + resource_id: Optional[str] = None, + resource_type: Optional[str] = None, + region: Optional[str] = None, + regions: Optional[List["ResourceRegion"]] = None, + subscription_id: Optional[str] = None, + resource_group_name: Optional[str] = None, + tags: Optional[Dict[str, str]] = None, + is_customer_managed: Optional[bool] = None, + is_private_link_resource: Optional[bool] = None, + is_private_link_resource_behind_vnet: Optional[bool] = None, + **kwargs + ): + """ + :keyword name: + :paramtype name: str + :keyword resource_id: + :paramtype resource_id: str + :keyword resource_type: + :paramtype resource_type: str + :keyword region: + :paramtype region: str + :keyword regions: + :paramtype regions: list[~index_service_apis.models.ResourceRegion] + :keyword subscription_id: + :paramtype subscription_id: str + :keyword resource_group_name: + :paramtype resource_group_name: str + :keyword tags: A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + :keyword is_customer_managed: + :paramtype is_customer_managed: bool + :keyword is_private_link_resource: + :paramtype is_private_link_resource: bool + :keyword is_private_link_resource_behind_vnet: + :paramtype is_private_link_resource_behind_vnet: bool + """ + super(IndexResourceDiscoveryResponseItem, self).__init__(**kwargs) + self.name = name + self.resource_id = resource_id + self.resource_type = resource_type + self.region = region + self.regions = regions + self.subscription_id = subscription_id + self.resource_group_name = resource_group_name + self.tags = tags + self.is_customer_managed = is_customer_managed + self.is_private_link_resource = is_private_link_resource + self.is_private_link_resource_behind_vnet = is_private_link_resource_behind_vnet + + +class IndexResourceDiscoveryResponseItemPaginatedResult(msrest.serialization.Model): + """IndexResourceDiscoveryResponseItemPaginatedResult. + + :ivar value: + :vartype value: list[~index_service_apis.models.IndexResourceDiscoveryResponseItem] + :ivar continuation_token: + :vartype continuation_token: str + :ivar next_link: + :vartype next_link: str + """ + + _attribute_map = { + "value": {"key": "value", "type": "[IndexResourceDiscoveryResponseItem]"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__( + self, + *, + value: Optional[List["IndexResourceDiscoveryResponseItem"]] = None, + continuation_token: Optional[str] = None, + next_link: Optional[str] = None, + **kwargs + ): + """ + :keyword value: + :paramtype value: list[~index_service_apis.models.IndexResourceDiscoveryResponseItem] + :keyword continuation_token: + :paramtype continuation_token: str + :keyword next_link: + :paramtype next_link: str + """ + super(IndexResourceDiscoveryResponseItemPaginatedResult, self).__init__(**kwargs) + self.value = value + self.continuation_token = continuation_token + self.next_link = next_link + + +class InnerErrorResponse(msrest.serialization.Model): + """InnerErrorResponse. + + :ivar code: + :vartype code: str + :ivar inner_error: + :vartype inner_error: ~index_service_apis.models.InnerErrorResponse + """ + + _attribute_map = { + "code": {"key": "code", "type": "str"}, + "inner_error": {"key": "innerError", "type": "InnerErrorResponse"}, + } + + def __init__(self, *, code: Optional[str] = None, inner_error: Optional["InnerErrorResponse"] = None, **kwargs): + """ + :keyword code: + :paramtype code: str + :keyword inner_error: + :paramtype inner_error: ~index_service_apis.models.InnerErrorResponse + """ + super(InnerErrorResponse, self).__init__(**kwargs) + self.code = code + self.inner_error = inner_error + + +class InputNameAndDataTypeIdsList(msrest.serialization.Model): + """InputNameAndDataTypeIdsList. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar data_type_ids_list: Required. + :vartype data_type_ids_list: list[str] + :ivar is_optional: Required. + :vartype is_optional: bool + :ivar description: Required. + :vartype description: str + :ivar label: Required. + :vartype label: str + """ + + _validation = { + "name": {"required": True}, + "data_type_ids_list": {"required": True}, + "is_optional": {"required": True}, + "description": {"required": True}, + "label": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "data_type_ids_list": {"key": "dataTypeIdsList", "type": "[str]"}, + "is_optional": {"key": "isOptional", "type": "bool"}, + "description": {"key": "description", "type": "str"}, + "label": {"key": "label", "type": "str"}, + } + + def __init__( + self, *, name: str, data_type_ids_list: List[str], is_optional: bool, description: str, label: str, **kwargs + ): + """ + :keyword name: Required. + :paramtype name: str + :keyword data_type_ids_list: Required. + :paramtype data_type_ids_list: list[str] + :keyword is_optional: Required. + :paramtype is_optional: bool + :keyword description: Required. + :paramtype description: str + :keyword label: Required. + :paramtype label: str + """ + super(InputNameAndDataTypeIdsList, self).__init__(**kwargs) + self.name = name + self.data_type_ids_list = data_type_ids_list + self.is_optional = is_optional + self.description = description + self.label = label + + +class InternalUxPresenceWarmUpRequest(msrest.serialization.Model): + """InternalUxPresenceWarmUpRequest. + + :ivar resources: + :vartype resources: list[~index_service_apis.models.UxPresenceResource] + :ivar source_ip: + :vartype source_ip: str + :ivar user_tenant_id: + :vartype user_tenant_id: str + :ivar user_object_id: + :vartype user_object_id: str + """ + + _attribute_map = { + "resources": {"key": "resources", "type": "[UxPresenceResource]"}, + "source_ip": {"key": "sourceIp", "type": "str"}, + "user_tenant_id": {"key": "userTenantId", "type": "str"}, + "user_object_id": {"key": "userObjectId", "type": "str"}, + } + + def __init__( + self, + *, + resources: Optional[List["UxPresenceResource"]] = None, + source_ip: Optional[str] = None, + user_tenant_id: Optional[str] = None, + user_object_id: Optional[str] = None, + **kwargs + ): + """ + :keyword resources: + :paramtype resources: list[~index_service_apis.models.UxPresenceResource] + :keyword source_ip: + :paramtype source_ip: str + :keyword user_tenant_id: + :paramtype user_tenant_id: str + :keyword user_object_id: + :paramtype user_object_id: str + """ + super(InternalUxPresenceWarmUpRequest, self).__init__(**kwargs) + self.resources = resources + self.source_ip = source_ip + self.user_tenant_id = user_tenant_id + self.user_object_id = user_object_id + + +class JobCost(msrest.serialization.Model): + """JobCost. + + All required parameters must be populated in order to send to Azure. + + :ivar charged_cpu_core_seconds: Required. + :vartype charged_cpu_core_seconds: float + :ivar charged_cpu_memory_megabyte_seconds: Required. + :vartype charged_cpu_memory_megabyte_seconds: float + :ivar charged_gpu_seconds: Required. + :vartype charged_gpu_seconds: float + :ivar charged_node_utilization_seconds: Required. + :vartype charged_node_utilization_seconds: float + """ + + _validation = { + "charged_cpu_core_seconds": {"required": True}, + "charged_cpu_memory_megabyte_seconds": {"required": True}, + "charged_gpu_seconds": {"required": True}, + "charged_node_utilization_seconds": {"required": True}, + } + + _attribute_map = { + "charged_cpu_core_seconds": {"key": "chargedCpuCoreSeconds", "type": "float"}, + "charged_cpu_memory_megabyte_seconds": {"key": "chargedCpuMemoryMegabyteSeconds", "type": "float"}, + "charged_gpu_seconds": {"key": "chargedGpuSeconds", "type": "float"}, + "charged_node_utilization_seconds": {"key": "chargedNodeUtilizationSeconds", "type": "float"}, + } + + def __init__( + self, + *, + charged_cpu_core_seconds: float, + charged_cpu_memory_megabyte_seconds: float, + charged_gpu_seconds: float, + charged_node_utilization_seconds: float, + **kwargs + ): + """ + :keyword charged_cpu_core_seconds: Required. + :paramtype charged_cpu_core_seconds: float + :keyword charged_cpu_memory_megabyte_seconds: Required. + :paramtype charged_cpu_memory_megabyte_seconds: float + :keyword charged_gpu_seconds: Required. + :paramtype charged_gpu_seconds: float + :keyword charged_node_utilization_seconds: Required. + :paramtype charged_node_utilization_seconds: float + """ + super(JobCost, self).__init__(**kwargs) + self.charged_cpu_core_seconds = charged_cpu_core_seconds + self.charged_cpu_memory_megabyte_seconds = charged_cpu_memory_megabyte_seconds + self.charged_gpu_seconds = charged_gpu_seconds + self.charged_node_utilization_seconds = charged_node_utilization_seconds + + +class MaterializationComputeResource(msrest.serialization.Model): + """MaterializationComputeResource. + + All required parameters must be populated in order to send to Azure. + + :ivar instance_type: Required. + :vartype instance_type: str + """ + + _validation = { + "instance_type": {"required": True}, + } + + _attribute_map = { + "instance_type": {"key": "instanceType", "type": "str"}, + } + + def __init__(self, *, instance_type: str, **kwargs): + """ + :keyword instance_type: Required. + :paramtype instance_type: str + """ + super(MaterializationComputeResource, self).__init__(**kwargs) + self.instance_type = instance_type + + +class MaterializationSettings(msrest.serialization.Model): + """MaterializationSettings. + + All required parameters must be populated in order to send to Azure. + + :ivar materialization_store_type: Required. Possible values include: "None", "Online", + "Offline", "OnlineAndOffline". + :vartype materialization_store_type: str or + ~index_service_apis.models.MaterializationSettingsMaterializationStoreType + :ivar schedule: Required. + :vartype schedule: ~index_service_apis.models.Recurrence + :ivar notification: + :vartype notification: ~index_service_apis.models.NotificationSetting + :ivar resource: Required. + :vartype resource: ~index_service_apis.models.MaterializationComputeResource + :ivar spark_configuration: Required. Dictionary of :code:`<string>`. + :vartype spark_configuration: dict[str, str] + """ + + _validation = { + "materialization_store_type": {"required": True}, + "schedule": {"required": True}, + "resource": {"required": True}, + "spark_configuration": {"required": True}, + } + + _attribute_map = { + "materialization_store_type": {"key": "materializationStoreType", "type": "str"}, + "schedule": {"key": "schedule", "type": "Recurrence"}, + "notification": {"key": "notification", "type": "NotificationSetting"}, + "resource": {"key": "resource", "type": "MaterializationComputeResource"}, + "spark_configuration": {"key": "sparkConfiguration", "type": "{str}"}, + } + + def __init__( + self, + *, + materialization_store_type: Union[str, "MaterializationSettingsMaterializationStoreType"], + schedule: "Recurrence", + resource: "MaterializationComputeResource", + spark_configuration: Dict[str, str], + notification: Optional["NotificationSetting"] = None, + **kwargs + ): + """ + :keyword materialization_store_type: Required. Possible values include: "None", "Online", + "Offline", "OnlineAndOffline". + :paramtype materialization_store_type: str or + ~index_service_apis.models.MaterializationSettingsMaterializationStoreType + :keyword schedule: Required. + :paramtype schedule: ~index_service_apis.models.Recurrence + :keyword notification: + :paramtype notification: ~index_service_apis.models.NotificationSetting + :keyword resource: Required. + :paramtype resource: ~index_service_apis.models.MaterializationComputeResource + :keyword spark_configuration: Required. Dictionary of :code:`<string>`. + :paramtype spark_configuration: dict[str, str] + """ + super(MaterializationSettings, self).__init__(**kwargs) + self.materialization_store_type = materialization_store_type + self.schedule = schedule + self.notification = notification + self.resource = resource + self.spark_configuration = spark_configuration + + +class ModelAnnotations(msrest.serialization.Model): + """ModelAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar datasets: Required. + :vartype datasets: list[~index_service_apis.models.DatasetReference] + :ivar sample_input_data: Required. + :vartype sample_input_data: str + :ivar sample_output_data: Required. + :vartype sample_output_data: str + :ivar resource_requirements: Required. + :vartype resource_requirements: ~index_service_apis.models.ContainerResourceRequirements + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "datasets": {"required": True}, + "sample_input_data": {"required": True}, + "sample_output_data": {"required": True}, + "resource_requirements": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "datasets": {"key": "datasets", "type": "[DatasetReference]"}, + "sample_input_data": {"key": "sampleInputData", "type": "str"}, + "sample_output_data": {"key": "sampleOutputData", "type": "str"}, + "resource_requirements": {"key": "resourceRequirements", "type": "ContainerResourceRequirements"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + datasets: List["DatasetReference"], + sample_input_data: str, + sample_output_data: str, + resource_requirements: "ContainerResourceRequirements", + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword datasets: Required. + :paramtype datasets: list[~index_service_apis.models.DatasetReference] + :keyword sample_input_data: Required. + :paramtype sample_input_data: str + :keyword sample_output_data: Required. + :paramtype sample_output_data: str + :keyword resource_requirements: Required. + :paramtype resource_requirements: ~index_service_apis.models.ContainerResourceRequirements + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(ModelAnnotations, self).__init__(**kwargs) + self.datasets = datasets + self.sample_input_data = sample_input_data + self.sample_output_data = sample_output_data + self.resource_requirements = resource_requirements + self.description = description + self.archived = archived + self.tags = tags + + +class ModelProperties(msrest.serialization.Model): + """ModelProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar name: Required. + :vartype name: str + :ivar model_framework: Required. + :vartype model_framework: str + :ivar model_framework_version: Required. + :vartype model_framework_version: str + :ivar model_format: Required. + :vartype model_format: str + :ivar version: Required. + :vartype version: int + :ivar alphanumeric_version: Required. + :vartype alphanumeric_version: str + :ivar url: Required. + :vartype url: str + :ivar mime_type: Required. + :vartype mime_type: str + :ivar modified_time: Required. + :vartype modified_time: ~datetime.datetime + :ivar unpack: Required. + :vartype unpack: bool + :ivar parent_model_id: Required. + :vartype parent_model_id: str + :ivar run_id: Required. + :vartype run_id: str + :ivar experiment_name: Required. + :vartype experiment_name: str + :ivar experiment_id: Required. + :vartype experiment_id: str + :ivar derived_model_ids: Required. + :vartype derived_model_ids: list[str] + :ivar user_properties: Required. Dictionary of :code:`<string>`. + :vartype user_properties: dict[str, str] + :ivar is_anonymous: Required. + :vartype is_anonymous: bool + :ivar orgin_asset_id: Required. + :vartype orgin_asset_id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "name": {"required": True}, + "model_framework": {"required": True}, + "model_framework_version": {"required": True}, + "model_format": {"required": True}, + "version": {"required": True}, + "alphanumeric_version": {"required": True}, + "url": {"required": True}, + "mime_type": {"required": True}, + "modified_time": {"required": True}, + "unpack": {"required": True}, + "parent_model_id": {"required": True}, + "run_id": {"required": True}, + "experiment_name": {"required": True}, + "experiment_id": {"required": True}, + "derived_model_ids": {"required": True}, + "user_properties": {"required": True}, + "is_anonymous": {"required": True}, + "orgin_asset_id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "model_framework": {"key": "modelFramework", "type": "str"}, + "model_framework_version": {"key": "modelFrameworkVersion", "type": "str"}, + "model_format": {"key": "modelFormat", "type": "str"}, + "version": {"key": "version", "type": "int"}, + "alphanumeric_version": {"key": "alphanumericVersion", "type": "str"}, + "url": {"key": "url", "type": "str"}, + "mime_type": {"key": "mimeType", "type": "str"}, + "modified_time": {"key": "modifiedTime", "type": "iso-8601"}, + "unpack": {"key": "unpack", "type": "bool"}, + "parent_model_id": {"key": "parentModelId", "type": "str"}, + "run_id": {"key": "runId", "type": "str"}, + "experiment_name": {"key": "experimentName", "type": "str"}, + "experiment_id": {"key": "experimentId", "type": "str"}, + "derived_model_ids": {"key": "derivedModelIds", "type": "[str]"}, + "user_properties": {"key": "userProperties", "type": "{str}"}, + "is_anonymous": {"key": "isAnonymous", "type": "bool"}, + "orgin_asset_id": {"key": "orginAssetId", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__( + self, + *, + id: str, + name: str, + model_framework: str, + model_framework_version: str, + model_format: str, + version: int, + alphanumeric_version: str, + url: str, + mime_type: str, + modified_time: datetime.datetime, + unpack: bool, + parent_model_id: str, + run_id: str, + experiment_name: str, + experiment_id: str, + derived_model_ids: List[str], + user_properties: Dict[str, str], + is_anonymous: bool, + orgin_asset_id: str, + creation_context: "CreationContext", + **kwargs + ): + """ + :keyword id: Required. + :paramtype id: str + :keyword name: Required. + :paramtype name: str + :keyword model_framework: Required. + :paramtype model_framework: str + :keyword model_framework_version: Required. + :paramtype model_framework_version: str + :keyword model_format: Required. + :paramtype model_format: str + :keyword version: Required. + :paramtype version: int + :keyword alphanumeric_version: Required. + :paramtype alphanumeric_version: str + :keyword url: Required. + :paramtype url: str + :keyword mime_type: Required. + :paramtype mime_type: str + :keyword modified_time: Required. + :paramtype modified_time: ~datetime.datetime + :keyword unpack: Required. + :paramtype unpack: bool + :keyword parent_model_id: Required. + :paramtype parent_model_id: str + :keyword run_id: Required. + :paramtype run_id: str + :keyword experiment_name: Required. + :paramtype experiment_name: str + :keyword experiment_id: Required. + :paramtype experiment_id: str + :keyword derived_model_ids: Required. + :paramtype derived_model_ids: list[str] + :keyword user_properties: Required. Dictionary of :code:`<string>`. + :paramtype user_properties: dict[str, str] + :keyword is_anonymous: Required. + :paramtype is_anonymous: bool + :keyword orgin_asset_id: Required. + :paramtype orgin_asset_id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(ModelProperties, self).__init__(**kwargs) + self.id = id + self.name = name + self.model_framework = model_framework + self.model_framework_version = model_framework_version + self.model_format = model_format + self.version = version + self.alphanumeric_version = alphanumeric_version + self.url = url + self.mime_type = mime_type + self.modified_time = modified_time + self.unpack = unpack + self.parent_model_id = parent_model_id + self.run_id = run_id + self.experiment_name = experiment_name + self.experiment_id = experiment_id + self.derived_model_ids = derived_model_ids + self.user_properties = user_properties + self.is_anonymous = is_anonymous + self.orgin_asset_id = orgin_asset_id + self.creation_context = creation_context + + +class ModelsVersionedEntitiesResponse(msrest.serialization.Model): + """ModelsVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.ModelsVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[ModelsVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["ModelsVersionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.ModelsVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(ModelsVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class ModelsVersionedEntity(msrest.serialization.Model): + """ModelsVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.ModelsVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.ModelAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.ModelProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "ModelAnnotations"}, + "properties": {"key": "properties", "type": "ModelProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "ModelsVersionedEntityKind"], + annotations: "ModelAnnotations", + properties: "ModelProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.ModelsVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.ModelAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.ModelProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(ModelsVersionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class ModuleAnnotations(msrest.serialization.Model): + """ModuleAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar module_name: Required. + :vartype module_name: str + :ivar display_name: Required. + :vartype display_name: str + :ivar lower_name: Required. + :vartype lower_name: str + :ivar module_version: Required. + :vartype module_version: str + :ivar inputs: Required. + :vartype inputs: list[~index_service_apis.models.InputNameAndDataTypeIdsList] + :ivar outputs: Required. + :vartype outputs: list[~index_service_apis.models.OutputNameAndDataTypeId] + :ivar category: Required. + :vartype category: str + :ivar step_type: Required. + :vartype step_type: str + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.ModuleAnnotationsEntityStatus + :ivar is_deterministic: Required. + :vartype is_deterministic: bool + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar last_updated_by: Required. + :vartype last_updated_by: ~index_service_apis.models.CreatedBy + :ivar component_type_version: Required. + :vartype component_type_version: str + :ivar snapshot_id: Required. + :vartype snapshot_id: str + :ivar runconfig: Required. + :vartype runconfig: str + :ivar control_outputs: Required. + :vartype control_outputs: list[~index_service_apis.models.ControlOutput] + :ivar parameters: Required. + :vartype parameters: list[~index_service_apis.models.StructuredInterfaceParameter] + :ivar metadata_parameters: Required. + :vartype metadata_parameters: list[~index_service_apis.models.StructuredInterfaceParameter] + :ivar aml_module_name: Required. + :vartype aml_module_name: str + :ivar aml_module_entity_status: Required. Possible values include: "Active", "Deprecated", + "Disabled". + :vartype aml_module_entity_status: str or + ~index_service_apis.models.ModuleAnnotationsAmlModuleEntityStatus + :ivar module_type: Required. Possible values include: "User", "Builtin". + :vartype module_type: str or ~index_service_apis.models.ModuleAnnotationsModuleType + :ivar module_execution_type: Required. + :vartype module_execution_type: str + :ivar arguments_serialized: Required. + :vartype arguments_serialized: str + :ivar cloud_settings_serialized: Required. + :vartype cloud_settings_serialized: str + :ivar stage: Required. + :vartype stage: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "module_name": {"required": True}, + "display_name": {"required": True}, + "lower_name": {"required": True}, + "module_version": {"required": True}, + "inputs": {"required": True}, + "outputs": {"required": True}, + "category": {"required": True}, + "step_type": {"required": True}, + "entity_status": {"required": True}, + "is_deterministic": {"required": True}, + "kv_tags": {"required": True}, + "properties": {"required": True}, + "last_modified_date": {"required": True}, + "last_updated_by": {"required": True}, + "component_type_version": {"required": True}, + "snapshot_id": {"required": True}, + "runconfig": {"required": True}, + "control_outputs": {"required": True}, + "parameters": {"required": True}, + "metadata_parameters": {"required": True}, + "aml_module_name": {"required": True}, + "aml_module_entity_status": {"required": True}, + "module_type": {"required": True}, + "module_execution_type": {"required": True}, + "arguments_serialized": {"required": True}, + "cloud_settings_serialized": {"required": True}, + "stage": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "module_name": {"key": "moduleName", "type": "str"}, + "display_name": {"key": "displayName", "type": "str"}, + "lower_name": {"key": "lowerName", "type": "str"}, + "module_version": {"key": "moduleVersion", "type": "str"}, + "inputs": {"key": "inputs", "type": "[InputNameAndDataTypeIdsList]"}, + "outputs": {"key": "outputs", "type": "[OutputNameAndDataTypeId]"}, + "category": {"key": "category", "type": "str"}, + "step_type": {"key": "stepType", "type": "str"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "is_deterministic": {"key": "isDeterministic", "type": "bool"}, + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"}, + "component_type_version": {"key": "componentTypeVersion", "type": "str"}, + "snapshot_id": {"key": "snapshotId", "type": "str"}, + "runconfig": {"key": "runconfig", "type": "str"}, + "control_outputs": {"key": "controlOutputs", "type": "[ControlOutput]"}, + "parameters": {"key": "parameters", "type": "[StructuredInterfaceParameter]"}, + "metadata_parameters": {"key": "metadataParameters", "type": "[StructuredInterfaceParameter]"}, + "aml_module_name": {"key": "amlModuleName", "type": "str"}, + "aml_module_entity_status": {"key": "amlModuleEntityStatus", "type": "str"}, + "module_type": {"key": "moduleType", "type": "str"}, + "module_execution_type": {"key": "moduleExecutionType", "type": "str"}, + "arguments_serialized": {"key": "argumentsSerialized", "type": "str"}, + "cloud_settings_serialized": {"key": "cloudSettingsSerialized", "type": "str"}, + "stage": {"key": "stage", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + module_name: str, + display_name: str, + lower_name: str, + module_version: str, + inputs: List["InputNameAndDataTypeIdsList"], + outputs: List["OutputNameAndDataTypeId"], + category: str, + step_type: str, + entity_status: Union[str, "ModuleAnnotationsEntityStatus"], + is_deterministic: bool, + kv_tags: Dict[str, str], + properties: Dict[str, str], + last_modified_date: datetime.datetime, + last_updated_by: "CreatedBy", + component_type_version: str, + snapshot_id: str, + runconfig: str, + control_outputs: List["ControlOutput"], + parameters: List["StructuredInterfaceParameter"], + metadata_parameters: List["StructuredInterfaceParameter"], + aml_module_name: str, + aml_module_entity_status: Union[str, "ModuleAnnotationsAmlModuleEntityStatus"], + module_type: Union[str, "ModuleAnnotationsModuleType"], + module_execution_type: str, + arguments_serialized: str, + cloud_settings_serialized: str, + stage: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword module_name: Required. + :paramtype module_name: str + :keyword display_name: Required. + :paramtype display_name: str + :keyword lower_name: Required. + :paramtype lower_name: str + :keyword module_version: Required. + :paramtype module_version: str + :keyword inputs: Required. + :paramtype inputs: list[~index_service_apis.models.InputNameAndDataTypeIdsList] + :keyword outputs: Required. + :paramtype outputs: list[~index_service_apis.models.OutputNameAndDataTypeId] + :keyword category: Required. + :paramtype category: str + :keyword step_type: Required. + :paramtype step_type: str + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or ~index_service_apis.models.ModuleAnnotationsEntityStatus + :keyword is_deterministic: Required. + :paramtype is_deterministic: bool + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword last_updated_by: Required. + :paramtype last_updated_by: ~index_service_apis.models.CreatedBy + :keyword component_type_version: Required. + :paramtype component_type_version: str + :keyword snapshot_id: Required. + :paramtype snapshot_id: str + :keyword runconfig: Required. + :paramtype runconfig: str + :keyword control_outputs: Required. + :paramtype control_outputs: list[~index_service_apis.models.ControlOutput] + :keyword parameters: Required. + :paramtype parameters: list[~index_service_apis.models.StructuredInterfaceParameter] + :keyword metadata_parameters: Required. + :paramtype metadata_parameters: list[~index_service_apis.models.StructuredInterfaceParameter] + :keyword aml_module_name: Required. + :paramtype aml_module_name: str + :keyword aml_module_entity_status: Required. Possible values include: "Active", "Deprecated", + "Disabled". + :paramtype aml_module_entity_status: str or + ~index_service_apis.models.ModuleAnnotationsAmlModuleEntityStatus + :keyword module_type: Required. Possible values include: "User", "Builtin". + :paramtype module_type: str or ~index_service_apis.models.ModuleAnnotationsModuleType + :keyword module_execution_type: Required. + :paramtype module_execution_type: str + :keyword arguments_serialized: Required. + :paramtype arguments_serialized: str + :keyword cloud_settings_serialized: Required. + :paramtype cloud_settings_serialized: str + :keyword stage: Required. + :paramtype stage: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(ModuleAnnotations, self).__init__(**kwargs) + self.module_name = module_name + self.display_name = display_name + self.lower_name = lower_name + self.module_version = module_version + self.inputs = inputs + self.outputs = outputs + self.category = category + self.step_type = step_type + self.entity_status = entity_status + self.is_deterministic = is_deterministic + self.kv_tags = kv_tags + self.properties = properties + self.last_modified_date = last_modified_date + self.last_updated_by = last_updated_by + self.component_type_version = component_type_version + self.snapshot_id = snapshot_id + self.runconfig = runconfig + self.control_outputs = control_outputs + self.parameters = parameters + self.metadata_parameters = metadata_parameters + self.aml_module_name = aml_module_name + self.aml_module_entity_status = aml_module_entity_status + self.module_type = module_type + self.module_execution_type = module_execution_type + self.arguments_serialized = arguments_serialized + self.cloud_settings_serialized = cloud_settings_serialized + self.stage = stage + self.description = description + self.archived = archived + self.tags = tags + + +class ModuleProperties(msrest.serialization.Model): + """ModuleProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar aml_module_id: Required. + :vartype aml_module_id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "aml_module_id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "aml_module_id": {"key": "amlModuleId", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, id: str, aml_module_id: str, creation_context: "CreationContext", **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword aml_module_id: Required. + :paramtype aml_module_id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(ModuleProperties, self).__init__(**kwargs) + self.id = id + self.aml_module_id = aml_module_id + self.creation_context = creation_context + + +class ModulesVersionedEntitiesResponse(msrest.serialization.Model): + """ModulesVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.ModulesVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[ModulesVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["ModulesVersionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.ModulesVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(ModulesVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class ModulesVersionedEntity(msrest.serialization.Model): + """ModulesVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.ModulesVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.ModuleAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.ModuleProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "ModuleAnnotations"}, + "properties": {"key": "properties", "type": "ModuleProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "ModulesVersionedEntityKind"], + annotations: "ModuleAnnotations", + properties: "ModuleProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.ModulesVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.ModuleAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.ModuleProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(ModulesVersionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class NotificationSetting(msrest.serialization.Model): + """NotificationSetting. + + All required parameters must be populated in order to send to Azure. + + :ivar emails: Required. + :vartype emails: list[str] + :ivar email_on: Required. + :vartype email_on: list[str or ~index_service_apis.models.NotificationSettingEmailOnItem] + :ivar webhooks: Required. Dictionary of :code:`<Webhook>`. + :vartype webhooks: dict[str, ~index_service_apis.models.Webhook] + """ + + _validation = { + "emails": {"required": True}, + "email_on": {"required": True}, + "webhooks": {"required": True}, + } + + _attribute_map = { + "emails": {"key": "emails", "type": "[str]"}, + "email_on": {"key": "emailOn", "type": "[str]"}, + "webhooks": {"key": "webhooks", "type": "{Webhook}"}, + } + + def __init__( + self, + *, + emails: List[str], + email_on: List[Union[str, "NotificationSettingEmailOnItem"]], + webhooks: Dict[str, "Webhook"], + **kwargs + ): + """ + :keyword emails: Required. + :paramtype emails: list[str] + :keyword email_on: Required. + :paramtype email_on: list[str or ~index_service_apis.models.NotificationSettingEmailOnItem] + :keyword webhooks: Required. Dictionary of :code:`<Webhook>`. + :paramtype webhooks: dict[str, ~index_service_apis.models.Webhook] + """ + super(NotificationSetting, self).__init__(**kwargs) + self.emails = emails + self.email_on = email_on + self.webhooks = webhooks + + +class OnlineEndpointAnnotations(msrest.serialization.Model): + """OnlineEndpointAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar compute_type: Required. + :vartype compute_type: str + :ivar compute_target: Required. + :vartype compute_target: ~index_service_apis.models.EndpointComputeTarget + :ivar scoring_uri: Required. + :vartype scoring_uri: str + :ivar location: Required. + :vartype location: str + :ivar last_modified_time: Required. + :vartype last_modified_time: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "compute_type": {"required": True}, + "compute_target": {"required": True}, + "scoring_uri": {"required": True}, + "location": {"required": True}, + "last_modified_time": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "compute_type": {"key": "computeType", "type": "str"}, + "compute_target": {"key": "computeTarget", "type": "EndpointComputeTarget"}, + "scoring_uri": {"key": "scoringUri", "type": "str"}, + "location": {"key": "location", "type": "str"}, + "last_modified_time": {"key": "lastModifiedTime", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + compute_type: str, + compute_target: "EndpointComputeTarget", + scoring_uri: str, + location: str, + last_modified_time: datetime.datetime, + name: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword compute_type: Required. + :paramtype compute_type: str + :keyword compute_target: Required. + :paramtype compute_target: ~index_service_apis.models.EndpointComputeTarget + :keyword scoring_uri: Required. + :paramtype scoring_uri: str + :keyword location: Required. + :paramtype location: str + :keyword last_modified_time: Required. + :paramtype last_modified_time: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(OnlineEndpointAnnotations, self).__init__(**kwargs) + self.compute_type = compute_type + self.compute_target = compute_target + self.scoring_uri = scoring_uri + self.location = location + self.last_modified_time = last_modified_time + self.name = name + self.description = description + self.archived = archived + self.tags = tags + + +class OnlineEndpointProperties(msrest.serialization.Model): + """OnlineEndpointProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "properties": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "properties": {"key": "properties", "type": "{str}"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, properties: Dict[str, str], creation_context: "CreationContext", **kwargs): + """ + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(OnlineEndpointProperties, self).__init__(**kwargs) + self.properties = properties + self.creation_context = creation_context + + +class OnlineendpointsUnversionedEntitiesResponse(msrest.serialization.Model): + """OnlineendpointsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.OnlineendpointsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[OnlineendpointsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["OnlineendpointsUnversionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.OnlineendpointsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(OnlineendpointsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class OnlineendpointsUnversionedEntity(msrest.serialization.Model): + """OnlineendpointsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.OnlineendpointsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.OnlineEndpointAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.OnlineEndpointProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "OnlineEndpointAnnotations"}, + "properties": {"key": "properties", "type": "OnlineEndpointProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "OnlineendpointsUnversionedEntityKind"], + annotations: "OnlineEndpointAnnotations", + properties: "OnlineEndpointProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.OnlineendpointsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.OnlineEndpointAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.OnlineEndpointProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(OnlineendpointsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class OutputNameAndDataTypeId(msrest.serialization.Model): + """OutputNameAndDataTypeId. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar data_type_id: Required. + :vartype data_type_id: str + :ivar description: Required. + :vartype description: str + :ivar label: Required. + :vartype label: str + """ + + _validation = { + "name": {"required": True}, + "data_type_id": {"required": True}, + "description": {"required": True}, + "label": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "data_type_id": {"key": "dataTypeId", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "label": {"key": "label", "type": "str"}, + } + + def __init__(self, *, name: str, data_type_id: str, description: str, label: str, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword data_type_id: Required. + :paramtype data_type_id: str + :keyword description: Required. + :paramtype description: str + :keyword label: Required. + :paramtype label: str + """ + super(OutputNameAndDataTypeId, self).__init__(**kwargs) + self.name = name + self.data_type_id = data_type_id + self.description = description + self.label = label + + +class PipelineAnnotations(msrest.serialization.Model): + """PipelineAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar pipeline_name: Required. + :vartype pipeline_name: str + :ivar version: Required. + :vartype version: str + :ivar url: Required. + :vartype url: str + :ivar pipeline_endpoint_ids: Required. + :vartype pipeline_endpoint_ids: list[str] + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar step_tags: Required. Dictionary of :code:`<string>`. + :vartype step_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar step_properties: Required. Dictionary of :code:`<string>`. + :vartype step_properties: dict[str, str] + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.PipelineAnnotationsEntityStatus + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar last_updated_by: Required. + :vartype last_updated_by: ~index_service_apis.models.CreatedBy + :ivar last_run_id: Required. + :vartype last_run_id: str + :ivar pipeline_type: Required. + :vartype pipeline_type: str + :ivar last_run_status_code: Required. Possible values include: "NotStarted", "Running", + "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested". + :vartype last_run_status_code: str or + ~index_service_apis.models.PipelineAnnotationsLastRunStatusCode + :ivar last_run_creation_time: Required. + :vartype last_run_creation_time: ~datetime.datetime + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "pipeline_name": {"required": True}, + "version": {"required": True}, + "url": {"required": True}, + "pipeline_endpoint_ids": {"required": True}, + "kv_tags": {"required": True}, + "step_tags": {"required": True}, + "properties": {"required": True}, + "step_properties": {"required": True}, + "entity_status": {"required": True}, + "last_modified_date": {"required": True}, + "last_updated_by": {"required": True}, + "last_run_id": {"required": True}, + "pipeline_type": {"required": True}, + "last_run_status_code": {"required": True}, + "last_run_creation_time": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "pipeline_name": {"key": "pipelineName", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "url": {"key": "url", "type": "str"}, + "pipeline_endpoint_ids": {"key": "pipelineEndpointIds", "type": "[str]"}, + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "step_tags": {"key": "stepTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "step_properties": {"key": "stepProperties", "type": "{str}"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "last_updated_by": {"key": "lastUpdatedBy", "type": "CreatedBy"}, + "last_run_id": {"key": "lastRunId", "type": "str"}, + "pipeline_type": {"key": "pipelineType", "type": "str"}, + "last_run_status_code": {"key": "lastRunStatusCode", "type": "str"}, + "last_run_creation_time": {"key": "lastRunCreationTime", "type": "iso-8601"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + pipeline_name: str, + version: str, + url: str, + pipeline_endpoint_ids: List[str], + kv_tags: Dict[str, str], + step_tags: Dict[str, str], + properties: Dict[str, str], + step_properties: Dict[str, str], + entity_status: Union[str, "PipelineAnnotationsEntityStatus"], + last_modified_date: datetime.datetime, + last_updated_by: "CreatedBy", + last_run_id: str, + pipeline_type: str, + last_run_status_code: Union[str, "PipelineAnnotationsLastRunStatusCode"], + last_run_creation_time: datetime.datetime, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword pipeline_name: Required. + :paramtype pipeline_name: str + :keyword version: Required. + :paramtype version: str + :keyword url: Required. + :paramtype url: str + :keyword pipeline_endpoint_ids: Required. + :paramtype pipeline_endpoint_ids: list[str] + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword step_tags: Required. Dictionary of :code:`<string>`. + :paramtype step_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword step_properties: Required. Dictionary of :code:`<string>`. + :paramtype step_properties: dict[str, str] + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or ~index_service_apis.models.PipelineAnnotationsEntityStatus + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword last_updated_by: Required. + :paramtype last_updated_by: ~index_service_apis.models.CreatedBy + :keyword last_run_id: Required. + :paramtype last_run_id: str + :keyword pipeline_type: Required. + :paramtype pipeline_type: str + :keyword last_run_status_code: Required. Possible values include: "NotStarted", "Running", + "Failed", "Finished", "Canceled", "Failing", "Queued", "CancelRequested". + :paramtype last_run_status_code: str or + ~index_service_apis.models.PipelineAnnotationsLastRunStatusCode + :keyword last_run_creation_time: Required. + :paramtype last_run_creation_time: ~datetime.datetime + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(PipelineAnnotations, self).__init__(**kwargs) + self.pipeline_name = pipeline_name + self.version = version + self.url = url + self.pipeline_endpoint_ids = pipeline_endpoint_ids + self.kv_tags = kv_tags + self.step_tags = step_tags + self.properties = properties + self.step_properties = step_properties + self.entity_status = entity_status + self.last_modified_date = last_modified_date + self.last_updated_by = last_updated_by + self.last_run_id = last_run_id + self.pipeline_type = pipeline_type + self.last_run_status_code = last_run_status_code + self.last_run_creation_time = last_run_creation_time + self.description = description + self.archived = archived + self.tags = tags + + +class PipelineDraftAnnotations(msrest.serialization.Model): + """PipelineDraftAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar step_tags: Required. Dictionary of :code:`<string>`. + :vartype step_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar step_properties: Required. Dictionary of :code:`<string>`. + :vartype step_properties: dict[str, str] + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.PipelineDraftAnnotationsEntityStatus + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar pipeline_type: Required. + :vartype pipeline_type: str + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "kv_tags": {"required": True}, + "step_tags": {"required": True}, + "properties": {"required": True}, + "step_properties": {"required": True}, + "entity_status": {"required": True}, + "last_modified_date": {"required": True}, + "pipeline_type": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "step_tags": {"key": "stepTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "step_properties": {"key": "stepProperties", "type": "{str}"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "pipeline_type": {"key": "pipelineType", "type": "str"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + kv_tags: Dict[str, str], + step_tags: Dict[str, str], + properties: Dict[str, str], + step_properties: Dict[str, str], + entity_status: Union[str, "PipelineDraftAnnotationsEntityStatus"], + last_modified_date: datetime.datetime, + pipeline_type: str, + name: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword step_tags: Required. Dictionary of :code:`<string>`. + :paramtype step_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword step_properties: Required. Dictionary of :code:`<string>`. + :paramtype step_properties: dict[str, str] + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or + ~index_service_apis.models.PipelineDraftAnnotationsEntityStatus + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword pipeline_type: Required. + :paramtype pipeline_type: str + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(PipelineDraftAnnotations, self).__init__(**kwargs) + self.kv_tags = kv_tags + self.step_tags = step_tags + self.properties = properties + self.step_properties = step_properties + self.entity_status = entity_status + self.last_modified_date = last_modified_date + self.pipeline_type = pipeline_type + self.name = name + self.description = description + self.archived = archived + self.tags = tags + + +class PipelineDraftProperties(msrest.serialization.Model): + """PipelineDraftProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(PipelineDraftProperties, self).__init__(**kwargs) + self.id = id + self.creation_context = creation_context + + +class PipelinedraftsUnversionedEntitiesResponse(msrest.serialization.Model): + """PipelinedraftsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.PipelinedraftsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[PipelinedraftsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["PipelinedraftsUnversionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.PipelinedraftsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(PipelinedraftsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class PipelinedraftsUnversionedEntity(msrest.serialization.Model): + """PipelinedraftsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.PipelinedraftsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.PipelineDraftAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.PipelineDraftProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "PipelineDraftAnnotations"}, + "properties": {"key": "properties", "type": "PipelineDraftProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "PipelinedraftsUnversionedEntityKind"], + annotations: "PipelineDraftAnnotations", + properties: "PipelineDraftProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.PipelinedraftsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.PipelineDraftAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.PipelineDraftProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(PipelinedraftsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class PipelineProperties(msrest.serialization.Model): + """PipelineProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(PipelineProperties, self).__init__(**kwargs) + self.id = id + self.creation_context = creation_context + + +class PipelineRunAnnotations(msrest.serialization.Model): + """PipelineRunAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar kv_tags: Required. Dictionary of :code:`<string>`. + :vartype kv_tags: dict[str, str] + :ivar step_tags: Required. Dictionary of :code:`<string>`. + :vartype step_tags: dict[str, str] + :ivar properties: Required. Dictionary of :code:`<string>`. + :vartype properties: dict[str, str] + :ivar step_properties: Required. Dictionary of :code:`<string>`. + :vartype step_properties: dict[str, str] + :ivar entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :vartype entity_status: str or ~index_service_apis.models.PipelineRunAnnotationsEntityStatus + :ivar status: Required. + :vartype status: ~index_service_apis.models.ExperimentStatus + :ivar run_history_experiment_name: Required. + :vartype run_history_experiment_name: str + :ivar has_errors: Required. + :vartype has_errors: bool + :ivar has_warnings: Required. + :vartype has_warnings: bool + :ivar last_modified_date: Required. + :vartype last_modified_date: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "kv_tags": {"required": True}, + "step_tags": {"required": True}, + "properties": {"required": True}, + "step_properties": {"required": True}, + "entity_status": {"required": True}, + "status": {"required": True}, + "run_history_experiment_name": {"required": True}, + "has_errors": {"required": True}, + "has_warnings": {"required": True}, + "last_modified_date": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "kv_tags": {"key": "kvTags", "type": "{str}"}, + "step_tags": {"key": "stepTags", "type": "{str}"}, + "properties": {"key": "properties", "type": "{str}"}, + "step_properties": {"key": "stepProperties", "type": "{str}"}, + "entity_status": {"key": "entityStatus", "type": "str"}, + "status": {"key": "status", "type": "ExperimentStatus"}, + "run_history_experiment_name": {"key": "runHistoryExperimentName", "type": "str"}, + "has_errors": {"key": "hasErrors", "type": "bool"}, + "has_warnings": {"key": "hasWarnings", "type": "bool"}, + "last_modified_date": {"key": "lastModifiedDate", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + kv_tags: Dict[str, str], + step_tags: Dict[str, str], + properties: Dict[str, str], + step_properties: Dict[str, str], + entity_status: Union[str, "PipelineRunAnnotationsEntityStatus"], + status: "ExperimentStatus", + run_history_experiment_name: str, + has_errors: bool, + has_warnings: bool, + last_modified_date: datetime.datetime, + name: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword kv_tags: Required. Dictionary of :code:`<string>`. + :paramtype kv_tags: dict[str, str] + :keyword step_tags: Required. Dictionary of :code:`<string>`. + :paramtype step_tags: dict[str, str] + :keyword properties: Required. Dictionary of :code:`<string>`. + :paramtype properties: dict[str, str] + :keyword step_properties: Required. Dictionary of :code:`<string>`. + :paramtype step_properties: dict[str, str] + :keyword entity_status: Required. Possible values include: "Active", "Deprecated", "Disabled". + :paramtype entity_status: str or ~index_service_apis.models.PipelineRunAnnotationsEntityStatus + :keyword status: Required. + :paramtype status: ~index_service_apis.models.ExperimentStatus + :keyword run_history_experiment_name: Required. + :paramtype run_history_experiment_name: str + :keyword has_errors: Required. + :paramtype has_errors: bool + :keyword has_warnings: Required. + :paramtype has_warnings: bool + :keyword last_modified_date: Required. + :paramtype last_modified_date: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(PipelineRunAnnotations, self).__init__(**kwargs) + self.kv_tags = kv_tags + self.step_tags = step_tags + self.properties = properties + self.step_properties = step_properties + self.entity_status = entity_status + self.status = status + self.run_history_experiment_name = run_history_experiment_name + self.has_errors = has_errors + self.has_warnings = has_warnings + self.last_modified_date = last_modified_date + self.name = name + self.description = description + self.archived = archived + self.tags = tags + + +class PipelineRunProperties(msrest.serialization.Model): + """PipelineRunProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar id: Required. + :vartype id: str + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "id": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "id": {"key": "id", "type": "str"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__(self, *, id: str, creation_context: "CreationContext", **kwargs): + """ + :keyword id: Required. + :paramtype id: str + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(PipelineRunProperties, self).__init__(**kwargs) + self.id = id + self.creation_context = creation_context + + +class PipelinerunsUnversionedEntitiesResponse(msrest.serialization.Model): + """PipelinerunsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.PipelinerunsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[PipelinerunsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["PipelinerunsUnversionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.PipelinerunsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(PipelinerunsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class PipelinerunsUnversionedEntity(msrest.serialization.Model): + """PipelinerunsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.PipelinerunsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.PipelineRunAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.PipelineRunProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "PipelineRunAnnotations"}, + "properties": {"key": "properties", "type": "PipelineRunProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "PipelinerunsUnversionedEntityKind"], + annotations: "PipelineRunAnnotations", + properties: "PipelineRunProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + relationships: List["Relationship"], + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.PipelinerunsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.PipelineRunAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.PipelineRunProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + """ + super(PipelinerunsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.relationships = relationships + + +class PipelinesVersionedEntitiesResponse(msrest.serialization.Model): + """PipelinesVersionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.PipelinesVersionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[PipelinesVersionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["PipelinesVersionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.PipelinesVersionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(PipelinesVersionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class PipelinesVersionedEntity(msrest.serialization.Model): + """PipelinesVersionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.PipelinesVersionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.PipelineAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.PipelineProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "PipelineAnnotations"}, + "properties": {"key": "properties", "type": "PipelineProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "PipelinesVersionedEntityKind"], + annotations: "PipelineAnnotations", + properties: "PipelineProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.PipelinesVersionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.PipelineAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.PipelineProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(PipelinesVersionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class Purpose(msrest.serialization.Model): + """Purpose. + + All required parameters must be populated in order to send to Azure. + + :ivar has_inferencing_support: Required. + :vartype has_inferencing_support: bool + :ivar has_training_support: Required. + :vartype has_training_support: bool + """ + + _validation = { + "has_inferencing_support": {"required": True}, + "has_training_support": {"required": True}, + } + + _attribute_map = { + "has_inferencing_support": {"key": "hasInferencingSupport", "type": "bool"}, + "has_training_support": {"key": "hasTrainingSupport", "type": "bool"}, + } + + def __init__(self, *, has_inferencing_support: bool, has_training_support: bool, **kwargs): + """ + :keyword has_inferencing_support: Required. + :paramtype has_inferencing_support: bool + :keyword has_training_support: Required. + :paramtype has_training_support: bool + """ + super(Purpose, self).__init__(**kwargs) + self.has_inferencing_support = has_inferencing_support + self.has_training_support = has_training_support + + +class Recurrence(msrest.serialization.Model): + """Recurrence. + + All required parameters must be populated in order to send to Azure. + + :ivar frequency: Required. Possible values include: "Month", "Week", "Day", "Hour", "Minute". + :vartype frequency: str or ~index_service_apis.models.RecurrenceFrequency + :ivar interval: Required. + :vartype interval: int + :ivar schedule: Required. + :vartype schedule: ~index_service_apis.models.RecurrenceSchedule + :ivar end_time: Required. + :vartype end_time: str + :ivar start_time: Required. + :vartype start_time: str + :ivar time_zone: Required. + :vartype time_zone: str + """ + + _validation = { + "frequency": {"required": True}, + "interval": {"required": True}, + "schedule": {"required": True}, + "end_time": {"required": True}, + "start_time": {"required": True}, + "time_zone": {"required": True}, + } + + _attribute_map = { + "frequency": {"key": "frequency", "type": "str"}, + "interval": {"key": "interval", "type": "int"}, + "schedule": {"key": "schedule", "type": "RecurrenceSchedule"}, + "end_time": {"key": "endTime", "type": "str"}, + "start_time": {"key": "startTime", "type": "str"}, + "time_zone": {"key": "timeZone", "type": "str"}, + } + + def __init__( + self, + *, + frequency: Union[str, "RecurrenceFrequency"], + interval: int, + schedule: "RecurrenceSchedule", + end_time: str, + start_time: str, + time_zone: str, + **kwargs + ): + """ + :keyword frequency: Required. Possible values include: "Month", "Week", "Day", "Hour", + "Minute". + :paramtype frequency: str or ~index_service_apis.models.RecurrenceFrequency + :keyword interval: Required. + :paramtype interval: int + :keyword schedule: Required. + :paramtype schedule: ~index_service_apis.models.RecurrenceSchedule + :keyword end_time: Required. + :paramtype end_time: str + :keyword start_time: Required. + :paramtype start_time: str + :keyword time_zone: Required. + :paramtype time_zone: str + """ + super(Recurrence, self).__init__(**kwargs) + self.frequency = frequency + self.interval = interval + self.schedule = schedule + self.end_time = end_time + self.start_time = start_time + self.time_zone = time_zone + + +class RecurrenceSchedule(msrest.serialization.Model): + """RecurrenceSchedule. + + :ivar hours: + :vartype hours: list[int] + :ivar minutes: + :vartype minutes: list[int] + :ivar week_days: + :vartype week_days: list[str or ~index_service_apis.models.RecurrenceScheduleWeekDaysItem] + :ivar month_days: + :vartype month_days: list[int] + """ + + _attribute_map = { + "hours": {"key": "hours", "type": "[int]"}, + "minutes": {"key": "minutes", "type": "[int]"}, + "week_days": {"key": "weekDays", "type": "[str]"}, + "month_days": {"key": "monthDays", "type": "[int]"}, + } + + def __init__( + self, + *, + hours: Optional[List[int]] = None, + minutes: Optional[List[int]] = None, + week_days: Optional[List[Union[str, "RecurrenceScheduleWeekDaysItem"]]] = None, + month_days: Optional[List[int]] = None, + **kwargs + ): + """ + :keyword hours: + :paramtype hours: list[int] + :keyword minutes: + :paramtype minutes: list[int] + :keyword week_days: + :paramtype week_days: list[str or ~index_service_apis.models.RecurrenceScheduleWeekDaysItem] + :keyword month_days: + :paramtype month_days: list[int] + """ + super(RecurrenceSchedule, self).__init__(**kwargs) + self.hours = hours + self.minutes = minutes + self.week_days = week_days + self.month_days = month_days + + +class RecurrenceTrigger(msrest.serialization.Model): + """RecurrenceTrigger. + + :ivar frequency: Possible values include: "Month", "Week", "Day", "Hour", "Minute". + :vartype frequency: str or ~index_service_apis.models.RecurrenceTriggerFrequency + :ivar interval: + :vartype interval: int + :ivar schedule: + :vartype schedule: ~index_service_apis.models.RecurrenceSchedule + """ + + _attribute_map = { + "frequency": {"key": "frequency", "type": "str"}, + "interval": {"key": "interval", "type": "int"}, + "schedule": {"key": "schedule", "type": "RecurrenceSchedule"}, + } + + def __init__( + self, + *, + frequency: Optional[Union[str, "RecurrenceTriggerFrequency"]] = None, + interval: Optional[int] = None, + schedule: Optional["RecurrenceSchedule"] = None, + **kwargs + ): + """ + :keyword frequency: Possible values include: "Month", "Week", "Day", "Hour", "Minute". + :paramtype frequency: str or ~index_service_apis.models.RecurrenceTriggerFrequency + :keyword interval: + :paramtype interval: int + :keyword schedule: + :paramtype schedule: ~index_service_apis.models.RecurrenceSchedule + """ + super(RecurrenceTrigger, self).__init__(**kwargs) + self.frequency = frequency + self.interval = interval + self.schedule = schedule + + +class Relationship(msrest.serialization.Model): + """Relationship. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar additional_properties: Unmatched properties from the message are deserialized to this + collection. + :vartype additional_properties: dict[str, any] + :ivar relation_type: + :vartype relation_type: str + :ivar target_entity_id: + :vartype target_entity_id: str + :ivar asset_id: + :vartype asset_id: str + :ivar entity_type: + :vartype entity_type: str + :ivar direction: + :vartype direction: str + :ivar entity_container_id: + :vartype entity_container_id: str + """ + + _validation = { + "entity_type": {"readonly": True}, + "entity_container_id": {"readonly": True}, + } + + _attribute_map = { + "additional_properties": {"key": "", "type": "{object}"}, + "relation_type": {"key": "relationType", "type": "str"}, + "target_entity_id": {"key": "targetEntityId", "type": "str"}, + "asset_id": {"key": "assetId", "type": "str"}, + "entity_type": {"key": "entityType", "type": "str"}, + "direction": {"key": "direction", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + } + + def __init__( + self, + *, + additional_properties: Optional[Dict[str, Any]] = None, + relation_type: Optional[str] = None, + target_entity_id: Optional[str] = None, + asset_id: Optional[str] = None, + direction: Optional[str] = None, + **kwargs + ): + """ + :keyword additional_properties: Unmatched properties from the message are deserialized to this + collection. + :paramtype additional_properties: dict[str, any] + :keyword relation_type: + :paramtype relation_type: str + :keyword target_entity_id: + :paramtype target_entity_id: str + :keyword asset_id: + :paramtype asset_id: str + :keyword direction: + :paramtype direction: str + """ + super(Relationship, self).__init__(**kwargs) + self.additional_properties = additional_properties + self.relation_type = relation_type + self.target_entity_id = target_entity_id + self.asset_id = asset_id + self.entity_type = None + self.direction = direction + self.entity_container_id = None + + +class ResourceDiscoveryContainerMetadata(msrest.serialization.Model): + """ResourceDiscoveryContainerMetadata. + + :ivar tags: A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + :ivar tenant_id: + :vartype tenant_id: str + :ivar resource_id: + :vartype resource_id: str + :ivar resource_arm_id: + :vartype resource_arm_id: str + :ivar subscription_id: + :vartype subscription_id: str + :ivar resource_group: + :vartype resource_group: str + :ivar resource_name: + :vartype resource_name: str + :ivar asset_container_type: + :vartype asset_container_type: str + :ivar immutable_resource_id: + :vartype immutable_resource_id: str + :ivar asset_resource_type: + :vartype asset_resource_type: str + :ivar is_customer_managed_resource: + :vartype is_customer_managed_resource: bool + :ivar is_private_link_behind_vnet: + :vartype is_private_link_behind_vnet: bool + :ivar is_public_container: + :vartype is_public_container: bool + :ivar is_public_resource: + :vartype is_public_resource: bool + :ivar regions: + :vartype regions: list[~index_service_apis.models.ResourceRegion] + """ + + _attribute_map = { + "tags": {"key": "tags", "type": "{str}"}, + "tenant_id": {"key": "tenantId", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + "resource_arm_id": {"key": "resourceArmId", "type": "str"}, + "subscription_id": {"key": "subscriptionId", "type": "str"}, + "resource_group": {"key": "resourceGroup", "type": "str"}, + "resource_name": {"key": "resourceName", "type": "str"}, + "asset_container_type": {"key": "assetContainerType", "type": "str"}, + "immutable_resource_id": {"key": "immutableResourceId", "type": "str"}, + "asset_resource_type": {"key": "assetResourceType", "type": "str"}, + "is_customer_managed_resource": {"key": "isCustomerManagedResource", "type": "bool"}, + "is_private_link_behind_vnet": {"key": "isPrivateLinkBehindVnet", "type": "bool"}, + "is_public_container": {"key": "isPublicContainer", "type": "bool"}, + "is_public_resource": {"key": "isPublicResource", "type": "bool"}, + "regions": {"key": "regions", "type": "[ResourceRegion]"}, + } + + def __init__( + self, + *, + tags: Optional[Dict[str, str]] = None, + tenant_id: Optional[str] = None, + resource_id: Optional[str] = None, + resource_arm_id: Optional[str] = None, + subscription_id: Optional[str] = None, + resource_group: Optional[str] = None, + resource_name: Optional[str] = None, + asset_container_type: Optional[str] = None, + immutable_resource_id: Optional[str] = None, + asset_resource_type: Optional[str] = None, + is_customer_managed_resource: Optional[bool] = None, + is_private_link_behind_vnet: Optional[bool] = None, + is_public_container: Optional[bool] = None, + is_public_resource: Optional[bool] = None, + regions: Optional[List["ResourceRegion"]] = None, + **kwargs + ): + """ + :keyword tags: A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + :keyword tenant_id: + :paramtype tenant_id: str + :keyword resource_id: + :paramtype resource_id: str + :keyword resource_arm_id: + :paramtype resource_arm_id: str + :keyword subscription_id: + :paramtype subscription_id: str + :keyword resource_group: + :paramtype resource_group: str + :keyword resource_name: + :paramtype resource_name: str + :keyword asset_container_type: + :paramtype asset_container_type: str + :keyword immutable_resource_id: + :paramtype immutable_resource_id: str + :keyword asset_resource_type: + :paramtype asset_resource_type: str + :keyword is_customer_managed_resource: + :paramtype is_customer_managed_resource: bool + :keyword is_private_link_behind_vnet: + :paramtype is_private_link_behind_vnet: bool + :keyword is_public_container: + :paramtype is_public_container: bool + :keyword is_public_resource: + :paramtype is_public_resource: bool + :keyword regions: + :paramtype regions: list[~index_service_apis.models.ResourceRegion] + """ + super(ResourceDiscoveryContainerMetadata, self).__init__(**kwargs) + self.tags = tags + self.tenant_id = tenant_id + self.resource_id = resource_id + self.resource_arm_id = resource_arm_id + self.subscription_id = subscription_id + self.resource_group = resource_group + self.resource_name = resource_name + self.asset_container_type = asset_container_type + self.immutable_resource_id = immutable_resource_id + self.asset_resource_type = asset_resource_type + self.is_customer_managed_resource = is_customer_managed_resource + self.is_private_link_behind_vnet = is_private_link_behind_vnet + self.is_public_container = is_public_container + self.is_public_resource = is_public_resource + self.regions = regions + + +class ResourceDiscoveryContainerMetadataPaginatedResult(msrest.serialization.Model): + """ResourceDiscoveryContainerMetadataPaginatedResult. + + :ivar value: + :vartype value: list[~index_service_apis.models.ResourceDiscoveryContainerMetadata] + :ivar continuation_token: + :vartype continuation_token: str + :ivar next_link: + :vartype next_link: str + """ + + _attribute_map = { + "value": {"key": "value", "type": "[ResourceDiscoveryContainerMetadata]"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "next_link": {"key": "nextLink", "type": "str"}, + } + + def __init__( + self, + *, + value: Optional[List["ResourceDiscoveryContainerMetadata"]] = None, + continuation_token: Optional[str] = None, + next_link: Optional[str] = None, + **kwargs + ): + """ + :keyword value: + :paramtype value: list[~index_service_apis.models.ResourceDiscoveryContainerMetadata] + :keyword continuation_token: + :paramtype continuation_token: str + :keyword next_link: + :paramtype next_link: str + """ + super(ResourceDiscoveryContainerMetadataPaginatedResult, self).__init__(**kwargs) + self.value = value + self.continuation_token = continuation_token + self.next_link = next_link + + +class ResourceDiscoveryRequest(msrest.serialization.Model): + """ResourceDiscoveryRequest. + + :ivar search_request: + :vartype search_request: ~index_service_apis.models.StringContainsRequest + :ivar order_by: + :vartype order_by: ~index_service_apis.models.IndexEntitiesRequestOrder + :ivar filters: + :vartype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :ivar page_size: + :vartype page_size: int + :ivar continuation_token: + :vartype continuation_token: str + """ + + _attribute_map = { + "search_request": {"key": "searchRequest", "type": "StringContainsRequest"}, + "order_by": {"key": "orderBy", "type": "IndexEntitiesRequestOrder"}, + "filters": {"key": "filters", "type": "[IndexEntitiesRequestFilter]"}, + "page_size": {"key": "pageSize", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + } + + def __init__( + self, + *, + search_request: Optional["StringContainsRequest"] = None, + order_by: Optional["IndexEntitiesRequestOrder"] = None, + filters: Optional[List["IndexEntitiesRequestFilter"]] = None, + page_size: Optional[int] = None, + continuation_token: Optional[str] = None, + **kwargs + ): + """ + :keyword search_request: + :paramtype search_request: ~index_service_apis.models.StringContainsRequest + :keyword order_by: + :paramtype order_by: ~index_service_apis.models.IndexEntitiesRequestOrder + :keyword filters: + :paramtype filters: list[~index_service_apis.models.IndexEntitiesRequestFilter] + :keyword page_size: + :paramtype page_size: int + :keyword continuation_token: + :paramtype continuation_token: str + """ + super(ResourceDiscoveryRequest, self).__init__(**kwargs) + self.search_request = search_request + self.order_by = order_by + self.filters = filters + self.page_size = page_size + self.continuation_token = continuation_token + + +class ResourceInformation(msrest.serialization.Model): + """ResourceInformation. + + :ivar region: + :vartype region: str + :ivar entity_container_type: Possible values include: "Workspace", "Feed", "Registry". + :vartype entity_container_type: str or ~index_service_apis.models.AssetContainerTypeFeedRename + :ivar resource_id: + :vartype resource_id: str + """ + + _attribute_map = { + "region": {"key": "region", "type": "str"}, + "entity_container_type": {"key": "entityContainerType", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + } + + def __init__( + self, + *, + region: Optional[str] = None, + entity_container_type: Optional[Union[str, "AssetContainerTypeFeedRename"]] = None, + resource_id: Optional[str] = None, + **kwargs + ): + """ + :keyword region: + :paramtype region: str + :keyword entity_container_type: Possible values include: "Workspace", "Feed", "Registry". + :paramtype entity_container_type: str or + ~index_service_apis.models.AssetContainerTypeFeedRename + :keyword resource_id: + :paramtype resource_id: str + """ + super(ResourceInformation, self).__init__(**kwargs) + self.region = region + self.entity_container_type = entity_container_type + self.resource_id = resource_id + + +class ResourceRegion(msrest.serialization.Model): + """ResourceRegion. + + :ivar region_name: + :vartype region_name: str + :ivar is_primary_region: + :vartype is_primary_region: bool + """ + + _attribute_map = { + "region_name": {"key": "regionName", "type": "str"}, + "is_primary_region": {"key": "isPrimaryRegion", "type": "bool"}, + } + + def __init__(self, *, region_name: Optional[str] = None, is_primary_region: Optional[bool] = None, **kwargs): + """ + :keyword region_name: + :paramtype region_name: str + :keyword is_primary_region: + :paramtype is_primary_region: bool + """ + super(ResourceRegion, self).__init__(**kwargs) + self.region_name = region_name + self.is_primary_region = is_primary_region + + +class RootError(msrest.serialization.Model): + """RootError. + + :ivar code: + :vartype code: str + :ivar severity: + :vartype severity: int + :ivar message: + :vartype message: str + :ivar message_format: + :vartype message_format: str + :ivar message_parameters: Dictionary of :code:`<string>`. + :vartype message_parameters: dict[str, str] + :ivar reference_code: + :vartype reference_code: str + :ivar details_uri: + :vartype details_uri: str + :ivar target: + :vartype target: str + :ivar details: + :vartype details: list[~index_service_apis.models.RootError] + :ivar inner_error: + :vartype inner_error: ~index_service_apis.models.InnerErrorResponse + :ivar debug_info: + :vartype debug_info: ~index_service_apis.models.DebugInfoResponse + :ivar additional_info: + :vartype additional_info: list[~index_service_apis.models.ErrorAdditionalInfo] + """ + + _attribute_map = { + "code": {"key": "code", "type": "str"}, + "severity": {"key": "severity", "type": "int"}, + "message": {"key": "message", "type": "str"}, + "message_format": {"key": "messageFormat", "type": "str"}, + "message_parameters": {"key": "messageParameters", "type": "{str}"}, + "reference_code": {"key": "referenceCode", "type": "str"}, + "details_uri": {"key": "detailsUri", "type": "str"}, + "target": {"key": "target", "type": "str"}, + "details": {"key": "details", "type": "[RootError]"}, + "inner_error": {"key": "innerError", "type": "InnerErrorResponse"}, + "debug_info": {"key": "debugInfo", "type": "DebugInfoResponse"}, + "additional_info": {"key": "additionalInfo", "type": "[ErrorAdditionalInfo]"}, + } + + def __init__( + self, + *, + code: Optional[str] = None, + severity: Optional[int] = None, + message: Optional[str] = None, + message_format: Optional[str] = None, + message_parameters: Optional[Dict[str, str]] = None, + reference_code: Optional[str] = None, + details_uri: Optional[str] = None, + target: Optional[str] = None, + details: Optional[List["RootError"]] = None, + inner_error: Optional["InnerErrorResponse"] = None, + debug_info: Optional["DebugInfoResponse"] = None, + additional_info: Optional[List["ErrorAdditionalInfo"]] = None, + **kwargs + ): + """ + :keyword code: + :paramtype code: str + :keyword severity: + :paramtype severity: int + :keyword message: + :paramtype message: str + :keyword message_format: + :paramtype message_format: str + :keyword message_parameters: Dictionary of :code:`<string>`. + :paramtype message_parameters: dict[str, str] + :keyword reference_code: + :paramtype reference_code: str + :keyword details_uri: + :paramtype details_uri: str + :keyword target: + :paramtype target: str + :keyword details: + :paramtype details: list[~index_service_apis.models.RootError] + :keyword inner_error: + :paramtype inner_error: ~index_service_apis.models.InnerErrorResponse + :keyword debug_info: + :paramtype debug_info: ~index_service_apis.models.DebugInfoResponse + :keyword additional_info: + :paramtype additional_info: list[~index_service_apis.models.ErrorAdditionalInfo] + """ + super(RootError, self).__init__(**kwargs) + self.code = code + self.severity = severity + self.message = message + self.message_format = message_format + self.message_parameters = message_parameters + self.reference_code = reference_code + self.details_uri = details_uri + self.target = target + self.details = details + self.inner_error = inner_error + self.debug_info = debug_info + self.additional_info = additional_info + + +class RunAnnotations(msrest.serialization.Model): + """RunAnnotations. + + All required parameters must be populated in order to send to Azure. + + :ivar display_name: Required. + :vartype display_name: str + :ivar status: Required. + :vartype status: str + :ivar primary_metric_name: Required. + :vartype primary_metric_name: str + :ivar estimated_cost: Required. + :vartype estimated_cost: float + :ivar primary_metric_summary: Required. + :vartype primary_metric_summary: ~index_service_apis.models.RunIndexMetricSummaryJValue + :ivar metrics: Required. Dictionary of <RunIndexMetricSummary:code:`<Object>`>. + :vartype metrics: dict[str, ~index_service_apis.models.RunIndexMetricSummaryObject] + :ivar parameters: Required. Dictionary of :code:`<AnyObject>`. + :vartype parameters: dict[str, any] + :ivar settings: Required. Dictionary of :code:`<string>`. + :vartype settings: dict[str, str] + :ivar modified_time: Required. + :vartype modified_time: ~datetime.datetime + :ivar retain_for_lifetime_of_workspace: Required. + :vartype retain_for_lifetime_of_workspace: bool + :ivar error: Required. + :vartype error: ~index_service_apis.models.IndexedErrorResponse + :ivar resource_metric_summary: Required. + :vartype resource_metric_summary: ~index_service_apis.models.RunIndexResourceMetricSummary + :ivar job_cost: Required. + :vartype job_cost: ~index_service_apis.models.JobCost + :ivar compute_duration: Required. + :vartype compute_duration: str + :ivar compute_duration_milliseconds: Required. + :vartype compute_duration_milliseconds: float + :ivar effective_start_time_utc: Required. + :vartype effective_start_time_utc: ~datetime.datetime + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar archived: Required. + :vartype archived: bool + :ivar tags: Required. A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + """ + + _validation = { + "display_name": {"required": True}, + "status": {"required": True}, + "primary_metric_name": {"required": True}, + "estimated_cost": {"required": True}, + "primary_metric_summary": {"required": True}, + "metrics": {"required": True}, + "parameters": {"required": True}, + "settings": {"required": True}, + "modified_time": {"required": True}, + "retain_for_lifetime_of_workspace": {"required": True}, + "error": {"required": True}, + "resource_metric_summary": {"required": True}, + "job_cost": {"required": True}, + "compute_duration": {"required": True}, + "compute_duration_milliseconds": {"required": True}, + "effective_start_time_utc": {"required": True}, + "name": {"required": True}, + "description": {"required": True}, + "archived": {"required": True}, + "tags": {"required": True}, + } + + _attribute_map = { + "display_name": {"key": "displayName", "type": "str"}, + "status": {"key": "status", "type": "str"}, + "primary_metric_name": {"key": "primaryMetricName", "type": "str"}, + "estimated_cost": {"key": "estimatedCost", "type": "float"}, + "primary_metric_summary": {"key": "primaryMetricSummary", "type": "RunIndexMetricSummaryJValue"}, + "metrics": {"key": "metrics", "type": "{RunIndexMetricSummaryObject}"}, + "parameters": {"key": "parameters", "type": "{object}"}, + "settings": {"key": "settings", "type": "{str}"}, + "modified_time": {"key": "modifiedTime", "type": "iso-8601"}, + "retain_for_lifetime_of_workspace": {"key": "retainForLifetimeOfWorkspace", "type": "bool"}, + "error": {"key": "error", "type": "IndexedErrorResponse"}, + "resource_metric_summary": {"key": "resourceMetricSummary", "type": "RunIndexResourceMetricSummary"}, + "job_cost": {"key": "jobCost", "type": "JobCost"}, + "compute_duration": {"key": "computeDuration", "type": "str"}, + "compute_duration_milliseconds": {"key": "computeDurationMilliseconds", "type": "float"}, + "effective_start_time_utc": {"key": "effectiveStartTimeUtc", "type": "iso-8601"}, + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "archived": {"key": "archived", "type": "bool"}, + "tags": {"key": "tags", "type": "{str}"}, + } + + def __init__( + self, + *, + display_name: str, + status: str, + primary_metric_name: str, + estimated_cost: float, + primary_metric_summary: "RunIndexMetricSummaryJValue", + metrics: Dict[str, "RunIndexMetricSummaryObject"], + parameters: Dict[str, Any], + settings: Dict[str, str], + modified_time: datetime.datetime, + retain_for_lifetime_of_workspace: bool, + error: "IndexedErrorResponse", + resource_metric_summary: "RunIndexResourceMetricSummary", + job_cost: "JobCost", + compute_duration: str, + compute_duration_milliseconds: float, + effective_start_time_utc: datetime.datetime, + name: str, + description: str, + archived: bool, + tags: Dict[str, str], + **kwargs + ): + """ + :keyword display_name: Required. + :paramtype display_name: str + :keyword status: Required. + :paramtype status: str + :keyword primary_metric_name: Required. + :paramtype primary_metric_name: str + :keyword estimated_cost: Required. + :paramtype estimated_cost: float + :keyword primary_metric_summary: Required. + :paramtype primary_metric_summary: ~index_service_apis.models.RunIndexMetricSummaryJValue + :keyword metrics: Required. Dictionary of <RunIndexMetricSummary:code:`<Object>`>. + :paramtype metrics: dict[str, ~index_service_apis.models.RunIndexMetricSummaryObject] + :keyword parameters: Required. Dictionary of :code:`<AnyObject>`. + :paramtype parameters: dict[str, any] + :keyword settings: Required. Dictionary of :code:`<string>`. + :paramtype settings: dict[str, str] + :keyword modified_time: Required. + :paramtype modified_time: ~datetime.datetime + :keyword retain_for_lifetime_of_workspace: Required. + :paramtype retain_for_lifetime_of_workspace: bool + :keyword error: Required. + :paramtype error: ~index_service_apis.models.IndexedErrorResponse + :keyword resource_metric_summary: Required. + :paramtype resource_metric_summary: ~index_service_apis.models.RunIndexResourceMetricSummary + :keyword job_cost: Required. + :paramtype job_cost: ~index_service_apis.models.JobCost + :keyword compute_duration: Required. + :paramtype compute_duration: str + :keyword compute_duration_milliseconds: Required. + :paramtype compute_duration_milliseconds: float + :keyword effective_start_time_utc: Required. + :paramtype effective_start_time_utc: ~datetime.datetime + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword archived: Required. + :paramtype archived: bool + :keyword tags: Required. A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + """ + super(RunAnnotations, self).__init__(**kwargs) + self.display_name = display_name + self.status = status + self.primary_metric_name = primary_metric_name + self.estimated_cost = estimated_cost + self.primary_metric_summary = primary_metric_summary + self.metrics = metrics + self.parameters = parameters + self.settings = settings + self.modified_time = modified_time + self.retain_for_lifetime_of_workspace = retain_for_lifetime_of_workspace + self.error = error + self.resource_metric_summary = resource_metric_summary + self.job_cost = job_cost + self.compute_duration = compute_duration + self.compute_duration_milliseconds = compute_duration_milliseconds + self.effective_start_time_utc = effective_start_time_utc + self.name = name + self.description = description + self.archived = archived + self.tags = tags + + +class RunIndexMetricSummaryJValue(msrest.serialization.Model): + """RunIndexMetricSummaryJValue. + + All required parameters must be populated in order to send to Azure. + + :ivar count: Required. + :vartype count: int + :ivar last_value: Required. Any object. + :vartype last_value: any + :ivar minimum_value: Required. Any object. + :vartype minimum_value: any + :ivar maximum_value: Required. Any object. + :vartype maximum_value: any + :ivar metric_type: Required. + :vartype metric_type: str + """ + + _validation = { + "count": {"required": True}, + "last_value": {"required": True}, + "minimum_value": {"required": True}, + "maximum_value": {"required": True}, + "metric_type": {"required": True}, + } + + _attribute_map = { + "count": {"key": "count", "type": "int"}, + "last_value": {"key": "lastValue", "type": "object"}, + "minimum_value": {"key": "minimumValue", "type": "object"}, + "maximum_value": {"key": "maximumValue", "type": "object"}, + "metric_type": {"key": "metricType", "type": "str"}, + } + + def __init__( + self, *, count: int, last_value: Any, minimum_value: Any, maximum_value: Any, metric_type: str, **kwargs + ): + """ + :keyword count: Required. + :paramtype count: int + :keyword last_value: Required. Any object. + :paramtype last_value: any + :keyword minimum_value: Required. Any object. + :paramtype minimum_value: any + :keyword maximum_value: Required. Any object. + :paramtype maximum_value: any + :keyword metric_type: Required. + :paramtype metric_type: str + """ + super(RunIndexMetricSummaryJValue, self).__init__(**kwargs) + self.count = count + self.last_value = last_value + self.minimum_value = minimum_value + self.maximum_value = maximum_value + self.metric_type = metric_type + + +class RunIndexMetricSummaryObject(msrest.serialization.Model): + """RunIndexMetricSummaryObject. + + All required parameters must be populated in order to send to Azure. + + :ivar count: Required. + :vartype count: int + :ivar last_value: Required. Anything. + :vartype last_value: any + :ivar minimum_value: Required. Anything. + :vartype minimum_value: any + :ivar maximum_value: Required. Anything. + :vartype maximum_value: any + :ivar metric_type: Required. + :vartype metric_type: str + """ + + _validation = { + "count": {"required": True}, + "last_value": {"required": True}, + "minimum_value": {"required": True}, + "maximum_value": {"required": True}, + "metric_type": {"required": True}, + } + + _attribute_map = { + "count": {"key": "count", "type": "int"}, + "last_value": {"key": "lastValue", "type": "object"}, + "minimum_value": {"key": "minimumValue", "type": "object"}, + "maximum_value": {"key": "maximumValue", "type": "object"}, + "metric_type": {"key": "metricType", "type": "str"}, + } + + def __init__( + self, *, count: int, last_value: Any, minimum_value: Any, maximum_value: Any, metric_type: str, **kwargs + ): + """ + :keyword count: Required. + :paramtype count: int + :keyword last_value: Required. Anything. + :paramtype last_value: any + :keyword minimum_value: Required. Anything. + :paramtype minimum_value: any + :keyword maximum_value: Required. Anything. + :paramtype maximum_value: any + :keyword metric_type: Required. + :paramtype metric_type: str + """ + super(RunIndexMetricSummaryObject, self).__init__(**kwargs) + self.count = count + self.last_value = last_value + self.minimum_value = minimum_value + self.maximum_value = maximum_value + self.metric_type = metric_type + + +class RunIndexResourceMetricSummary(msrest.serialization.Model): + """RunIndexResourceMetricSummary. + + All required parameters must be populated in order to send to Azure. + + :ivar gpu_utilization_percent_last_hour: Required. + :vartype gpu_utilization_percent_last_hour: float + :ivar gpu_memory_utilization_percent_last_hour: Required. + :vartype gpu_memory_utilization_percent_last_hour: float + :ivar gpu_energy_joules: Required. + :vartype gpu_energy_joules: float + :ivar resource_metric_names: Required. + :vartype resource_metric_names: list[str] + """ + + _validation = { + "gpu_utilization_percent_last_hour": {"required": True}, + "gpu_memory_utilization_percent_last_hour": {"required": True}, + "gpu_energy_joules": {"required": True}, + "resource_metric_names": {"required": True}, + } + + _attribute_map = { + "gpu_utilization_percent_last_hour": {"key": "gpuUtilizationPercentLastHour", "type": "float"}, + "gpu_memory_utilization_percent_last_hour": {"key": "gpuMemoryUtilizationPercentLastHour", "type": "float"}, + "gpu_energy_joules": {"key": "gpuEnergyJoules", "type": "float"}, + "resource_metric_names": {"key": "resourceMetricNames", "type": "[str]"}, + } + + def __init__( + self, + *, + gpu_utilization_percent_last_hour: float, + gpu_memory_utilization_percent_last_hour: float, + gpu_energy_joules: float, + resource_metric_names: List[str], + **kwargs + ): + """ + :keyword gpu_utilization_percent_last_hour: Required. + :paramtype gpu_utilization_percent_last_hour: float + :keyword gpu_memory_utilization_percent_last_hour: Required. + :paramtype gpu_memory_utilization_percent_last_hour: float + :keyword gpu_energy_joules: Required. + :paramtype gpu_energy_joules: float + :keyword resource_metric_names: Required. + :paramtype resource_metric_names: list[str] + """ + super(RunIndexResourceMetricSummary, self).__init__(**kwargs) + self.gpu_utilization_percent_last_hour = gpu_utilization_percent_last_hour + self.gpu_memory_utilization_percent_last_hour = gpu_memory_utilization_percent_last_hour + self.gpu_energy_joules = gpu_energy_joules + self.resource_metric_names = resource_metric_names + + +class RunProperties(msrest.serialization.Model): + """RunProperties. + + All required parameters must be populated in order to send to Azure. + + :ivar data_container_id: Required. + :vartype data_container_id: str + :ivar target_name: Required. + :vartype target_name: str + :ivar run_name: Required. + :vartype run_name: str + :ivar experiment_name: Required. + :vartype experiment_name: str + :ivar run_id: Required. + :vartype run_id: str + :ivar parent_run_id: Required. + :vartype parent_run_id: str + :ivar root_run_id: Required. + :vartype root_run_id: str + :ivar run_type: Required. + :vartype run_type: str + :ivar run_type_v2: Required. + :vartype run_type_v2: ~index_service_apis.models.RunTypeV2Index + :ivar script_name: Required. + :vartype script_name: str + :ivar experiment_id: Required. + :vartype experiment_id: str + :ivar run_uuid: Required. + :vartype run_uuid: str + :ivar parent_run_uuid: Required. + :vartype parent_run_uuid: str + :ivar run_number: Required. + :vartype run_number: int + :ivar start_time: Required. + :vartype start_time: ~datetime.datetime + :ivar end_time: Required. + :vartype end_time: ~datetime.datetime + :ivar compute_request: Required. + :vartype compute_request: ~index_service_apis.models.ComputeRequest + :ivar compute: Required. + :vartype compute: ~index_service_apis.models.Compute + :ivar user_properties: Required. Dictionary of :code:`<string>`. + :vartype user_properties: dict[str, str] + :ivar action_uris: Required. Dictionary of :code:`<string>`. + :vartype action_uris: dict[str, str] + :ivar duration: Required. + :vartype duration: str + :ivar duration_milliseconds: Required. + :vartype duration_milliseconds: float + :ivar creation_context: Required. + :vartype creation_context: ~index_service_apis.models.CreationContext + """ + + _validation = { + "data_container_id": {"required": True}, + "target_name": {"required": True}, + "run_name": {"required": True}, + "experiment_name": {"required": True}, + "run_id": {"required": True}, + "parent_run_id": {"required": True}, + "root_run_id": {"required": True}, + "run_type": {"required": True}, + "run_type_v2": {"required": True}, + "script_name": {"required": True}, + "experiment_id": {"required": True}, + "run_uuid": {"required": True}, + "parent_run_uuid": {"required": True}, + "run_number": {"required": True}, + "start_time": {"required": True}, + "end_time": {"required": True}, + "compute_request": {"required": True}, + "compute": {"required": True}, + "user_properties": {"required": True}, + "action_uris": {"required": True}, + "duration": {"required": True}, + "duration_milliseconds": {"required": True}, + "creation_context": {"required": True}, + } + + _attribute_map = { + "data_container_id": {"key": "dataContainerId", "type": "str"}, + "target_name": {"key": "targetName", "type": "str"}, + "run_name": {"key": "runName", "type": "str"}, + "experiment_name": {"key": "experimentName", "type": "str"}, + "run_id": {"key": "runId", "type": "str"}, + "parent_run_id": {"key": "parentRunId", "type": "str"}, + "root_run_id": {"key": "rootRunId", "type": "str"}, + "run_type": {"key": "runType", "type": "str"}, + "run_type_v2": {"key": "runTypeV2", "type": "RunTypeV2Index"}, + "script_name": {"key": "scriptName", "type": "str"}, + "experiment_id": {"key": "experimentId", "type": "str"}, + "run_uuid": {"key": "runUuid", "type": "str"}, + "parent_run_uuid": {"key": "parentRunUuid", "type": "str"}, + "run_number": {"key": "runNumber", "type": "int"}, + "start_time": {"key": "startTime", "type": "iso-8601"}, + "end_time": {"key": "endTime", "type": "iso-8601"}, + "compute_request": {"key": "computeRequest", "type": "ComputeRequest"}, + "compute": {"key": "compute", "type": "Compute"}, + "user_properties": {"key": "userProperties", "type": "{str}"}, + "action_uris": {"key": "actionUris", "type": "{str}"}, + "duration": {"key": "duration", "type": "str"}, + "duration_milliseconds": {"key": "durationMilliseconds", "type": "float"}, + "creation_context": {"key": "creationContext", "type": "CreationContext"}, + } + + def __init__( + self, + *, + data_container_id: str, + target_name: str, + run_name: str, + experiment_name: str, + run_id: str, + parent_run_id: str, + root_run_id: str, + run_type: str, + run_type_v2: "RunTypeV2Index", + script_name: str, + experiment_id: str, + run_uuid: str, + parent_run_uuid: str, + run_number: int, + start_time: datetime.datetime, + end_time: datetime.datetime, + compute_request: "ComputeRequest", + compute: "Compute", + user_properties: Dict[str, str], + action_uris: Dict[str, str], + duration: str, + duration_milliseconds: float, + creation_context: "CreationContext", + **kwargs + ): + """ + :keyword data_container_id: Required. + :paramtype data_container_id: str + :keyword target_name: Required. + :paramtype target_name: str + :keyword run_name: Required. + :paramtype run_name: str + :keyword experiment_name: Required. + :paramtype experiment_name: str + :keyword run_id: Required. + :paramtype run_id: str + :keyword parent_run_id: Required. + :paramtype parent_run_id: str + :keyword root_run_id: Required. + :paramtype root_run_id: str + :keyword run_type: Required. + :paramtype run_type: str + :keyword run_type_v2: Required. + :paramtype run_type_v2: ~index_service_apis.models.RunTypeV2Index + :keyword script_name: Required. + :paramtype script_name: str + :keyword experiment_id: Required. + :paramtype experiment_id: str + :keyword run_uuid: Required. + :paramtype run_uuid: str + :keyword parent_run_uuid: Required. + :paramtype parent_run_uuid: str + :keyword run_number: Required. + :paramtype run_number: int + :keyword start_time: Required. + :paramtype start_time: ~datetime.datetime + :keyword end_time: Required. + :paramtype end_time: ~datetime.datetime + :keyword compute_request: Required. + :paramtype compute_request: ~index_service_apis.models.ComputeRequest + :keyword compute: Required. + :paramtype compute: ~index_service_apis.models.Compute + :keyword user_properties: Required. Dictionary of :code:`<string>`. + :paramtype user_properties: dict[str, str] + :keyword action_uris: Required. Dictionary of :code:`<string>`. + :paramtype action_uris: dict[str, str] + :keyword duration: Required. + :paramtype duration: str + :keyword duration_milliseconds: Required. + :paramtype duration_milliseconds: float + :keyword creation_context: Required. + :paramtype creation_context: ~index_service_apis.models.CreationContext + """ + super(RunProperties, self).__init__(**kwargs) + self.data_container_id = data_container_id + self.target_name = target_name + self.run_name = run_name + self.experiment_name = experiment_name + self.run_id = run_id + self.parent_run_id = parent_run_id + self.root_run_id = root_run_id + self.run_type = run_type + self.run_type_v2 = run_type_v2 + self.script_name = script_name + self.experiment_id = experiment_id + self.run_uuid = run_uuid + self.parent_run_uuid = parent_run_uuid + self.run_number = run_number + self.start_time = start_time + self.end_time = end_time + self.compute_request = compute_request + self.compute = compute + self.user_properties = user_properties + self.action_uris = action_uris + self.duration = duration + self.duration_milliseconds = duration_milliseconds + self.creation_context = creation_context + + +class RunsUnversionedEntitiesResponse(msrest.serialization.Model): + """RunsUnversionedEntitiesResponse. + + :ivar total_count: + :vartype total_count: long + :ivar value: + :vartype value: list[~index_service_apis.models.RunsUnversionedEntity] + :ivar next_skip: + :vartype next_skip: int + :ivar continuation_token: + :vartype continuation_token: str + :ivar entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :vartype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :ivar number_of_entity_containers_not_queried: + :vartype number_of_entity_containers_not_queried: int + :ivar fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :vartype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :ivar shard_errors: Dictionary of :code:`<ErrorResponse>`. + :vartype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :ivar + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :vartype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + "value": {"key": "value", "type": "[RunsUnversionedEntity]"}, + "next_skip": {"key": "nextSkip", "type": "int"}, + "continuation_token": {"key": "continuationToken", "type": "str"}, + "entity_container_ids_to_entity_container_metadata": { + "key": "entityContainerIdsToEntityContainerMetadata", + "type": "{IndexEntityContainerMetadata}", + }, + "number_of_entity_containers_not_queried": {"key": "numberOfEntityContainersNotQueried", "type": "int"}, + "fanout_data": {"key": "fanoutData", "type": "{SingleShardFanoutData}"}, + "shard_errors": {"key": "shardErrors", "type": "{ErrorResponse}"}, + "is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern": { + "key": "isMultiWorkspaceQueryWithSkipSetWhichWillNoLongerBeASupportedCallingPattern", + "type": "bool", + }, + } + + def __init__( + self, + *, + total_count: Optional[int] = None, + value: Optional[List["RunsUnversionedEntity"]] = None, + next_skip: Optional[int] = None, + continuation_token: Optional[str] = None, + entity_container_ids_to_entity_container_metadata: Optional[Dict[str, "IndexEntityContainerMetadata"]] = None, + number_of_entity_containers_not_queried: Optional[int] = None, + fanout_data: Optional[Dict[str, "SingleShardFanoutData"]] = None, + shard_errors: Optional[Dict[str, "ErrorResponse"]] = None, + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: Optional[ + bool + ] = None, + **kwargs + ): + """ + :keyword total_count: + :paramtype total_count: long + :keyword value: + :paramtype value: list[~index_service_apis.models.RunsUnversionedEntity] + :keyword next_skip: + :paramtype next_skip: int + :keyword continuation_token: + :paramtype continuation_token: str + :keyword entity_container_ids_to_entity_container_metadata: Dictionary of + :code:`<IndexEntityContainerMetadata>`. + :paramtype entity_container_ids_to_entity_container_metadata: dict[str, + ~index_service_apis.models.IndexEntityContainerMetadata] + :keyword number_of_entity_containers_not_queried: + :paramtype number_of_entity_containers_not_queried: int + :keyword fanout_data: Dictionary of :code:`<SingleShardFanoutData>`. + :paramtype fanout_data: dict[str, ~index_service_apis.models.SingleShardFanoutData] + :keyword shard_errors: Dictionary of :code:`<ErrorResponse>`. + :paramtype shard_errors: dict[str, ~index_service_apis.models.ErrorResponse] + :keyword + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + :paramtype + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern: + bool + """ + super(RunsUnversionedEntitiesResponse, self).__init__(**kwargs) + self.total_count = total_count + self.value = value + self.next_skip = next_skip + self.continuation_token = continuation_token + self.entity_container_ids_to_entity_container_metadata = entity_container_ids_to_entity_container_metadata + self.number_of_entity_containers_not_queried = number_of_entity_containers_not_queried + self.fanout_data = fanout_data + self.shard_errors = shard_errors + self.is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern = ( + is_multi_workspace_query_with_skip_set_which_will_no_longer_be_a_supported_calling_pattern + ) + + +class RunsUnversionedEntity(msrest.serialization.Model): + """RunsUnversionedEntity. + + All required parameters must be populated in order to send to Azure. + + :ivar schema_id: Required. + :vartype schema_id: str + :ivar entity_id: Required. + :vartype entity_id: str + :ivar kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :vartype kind: str or ~index_service_apis.models.RunsUnversionedEntityKind + :ivar annotations: Required. + :vartype annotations: ~index_service_apis.models.RunAnnotations + :ivar properties: Required. + :vartype properties: ~index_service_apis.models.RunProperties + :ivar internal: Required. Dictionary of :code:`<any>`. + :vartype internal: dict[str, any] + :ivar update_sequence: Required. + :vartype update_sequence: int + :ivar type: Required. + :vartype type: str + :ivar version: Required. + :vartype version: str + :ivar entity_container_id: Required. + :vartype entity_container_id: str + :ivar entity_object_id: Required. + :vartype entity_object_id: str + :ivar resource_type: Required. + :vartype resource_type: str + :ivar relationships: Required. + :vartype relationships: list[~index_service_apis.models.Relationship] + :ivar asset_id: + :vartype asset_id: str + """ + + _validation = { + "schema_id": {"required": True}, + "entity_id": {"required": True}, + "kind": {"required": True}, + "annotations": {"required": True}, + "properties": {"required": True}, + "internal": {"required": True}, + "update_sequence": {"required": True}, + "type": {"required": True}, + "version": {"required": True}, + "entity_container_id": {"required": True}, + "entity_object_id": {"required": True}, + "resource_type": {"required": True}, + "relationships": {"required": True}, + } + + _attribute_map = { + "schema_id": {"key": "schemaId", "type": "str"}, + "entity_id": {"key": "entityId", "type": "str"}, + "kind": {"key": "kind", "type": "str"}, + "annotations": {"key": "annotations", "type": "RunAnnotations"}, + "properties": {"key": "properties", "type": "RunProperties"}, + "internal": {"key": "internal", "type": "{object}"}, + "update_sequence": {"key": "updateSequence", "type": "int"}, + "type": {"key": "type", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "entity_container_id": {"key": "entityContainerId", "type": "str"}, + "entity_object_id": {"key": "entityObjectId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "relationships": {"key": "relationships", "type": "[Relationship]"}, + "asset_id": {"key": "assetId", "type": "str"}, + } + + def __init__( + self, + *, + schema_id: str, + entity_id: str, + kind: Union[str, "RunsUnversionedEntityKind"], + annotations: "RunAnnotations", + properties: "RunProperties", + internal: Dict[str, Any], + update_sequence: int, + type: str, + version: str, + entity_container_id: str, + entity_object_id: str, + resource_type: str, + relationships: List["Relationship"], + asset_id: Optional[str] = None, + **kwargs + ): + """ + :keyword schema_id: Required. + :paramtype schema_id: str + :keyword entity_id: Required. + :paramtype entity_id: str + :keyword kind: Required. Possible values include: "Invalid", "LineageRoot", "Versioned", + "Unversioned". + :paramtype kind: str or ~index_service_apis.models.RunsUnversionedEntityKind + :keyword annotations: Required. + :paramtype annotations: ~index_service_apis.models.RunAnnotations + :keyword properties: Required. + :paramtype properties: ~index_service_apis.models.RunProperties + :keyword internal: Required. Dictionary of :code:`<any>`. + :paramtype internal: dict[str, any] + :keyword update_sequence: Required. + :paramtype update_sequence: int + :keyword type: Required. + :paramtype type: str + :keyword version: Required. + :paramtype version: str + :keyword entity_container_id: Required. + :paramtype entity_container_id: str + :keyword entity_object_id: Required. + :paramtype entity_object_id: str + :keyword resource_type: Required. + :paramtype resource_type: str + :keyword relationships: Required. + :paramtype relationships: list[~index_service_apis.models.Relationship] + :keyword asset_id: + :paramtype asset_id: str + """ + super(RunsUnversionedEntity, self).__init__(**kwargs) + self.schema_id = schema_id + self.entity_id = entity_id + self.kind = kind + self.annotations = annotations + self.properties = properties + self.internal = internal + self.update_sequence = update_sequence + self.type = type + self.version = version + self.entity_container_id = entity_container_id + self.entity_object_id = entity_object_id + self.resource_type = resource_type + self.relationships = relationships + self.asset_id = asset_id + + +class RunTypeV2Index(msrest.serialization.Model): + """RunTypeV2Index. + + All required parameters must be populated in order to send to Azure. + + :ivar orchestrator: Required. + :vartype orchestrator: str + :ivar traits: Required. Dictionary of :code:`<string>`. + :vartype traits: dict[str, str] + :ivar attribution: Required. + :vartype attribution: str + :ivar compute_type: Required. + :vartype compute_type: str + """ + + _validation = { + "orchestrator": {"required": True}, + "traits": {"required": True}, + "attribution": {"required": True}, + "compute_type": {"required": True}, + } + + _attribute_map = { + "orchestrator": {"key": "orchestrator", "type": "str"}, + "traits": {"key": "traits", "type": "{str}"}, + "attribution": {"key": "attribution", "type": "str"}, + "compute_type": {"key": "computeType", "type": "str"}, + } + + def __init__(self, *, orchestrator: str, traits: Dict[str, str], attribution: str, compute_type: str, **kwargs): + """ + :keyword orchestrator: Required. + :paramtype orchestrator: str + :keyword traits: Required. Dictionary of :code:`<string>`. + :paramtype traits: dict[str, str] + :keyword attribution: Required. + :paramtype attribution: str + :keyword compute_type: Required. + :paramtype compute_type: str + """ + super(RunTypeV2Index, self).__init__(**kwargs) + self.orchestrator = orchestrator + self.traits = traits + self.attribution = attribution + self.compute_type = compute_type + + +class SingleShardFanoutData(msrest.serialization.Model): + """SingleShardFanoutData. + + :ivar next_skip: + :vartype next_skip: int + :ivar is_shard_done: + :vartype is_shard_done: bool + :ivar did_shard_fail: + :vartype did_shard_fail: bool + :ivar total_count: + :vartype total_count: long + """ + + _attribute_map = { + "next_skip": {"key": "nextSkip", "type": "int"}, + "is_shard_done": {"key": "isShardDone", "type": "bool"}, + "did_shard_fail": {"key": "didShardFail", "type": "bool"}, + "total_count": {"key": "totalCount", "type": "long"}, + } + + def __init__( + self, + *, + next_skip: Optional[int] = None, + is_shard_done: Optional[bool] = None, + did_shard_fail: Optional[bool] = None, + total_count: Optional[int] = None, + **kwargs + ): + """ + :keyword next_skip: + :paramtype next_skip: int + :keyword is_shard_done: + :paramtype is_shard_done: bool + :keyword did_shard_fail: + :paramtype did_shard_fail: bool + :keyword total_count: + :paramtype total_count: long + """ + super(SingleShardFanoutData, self).__init__(**kwargs) + self.next_skip = next_skip + self.is_shard_done = is_shard_done + self.did_shard_fail = did_shard_fail + self.total_count = total_count + + +class StringContainsRequest(msrest.serialization.Model): + """StringContainsRequest. + + :ivar value_to_check: + :vartype value_to_check: str + :ivar columns_to_check: + :vartype columns_to_check: list[str] + """ + + _attribute_map = { + "value_to_check": {"key": "valueToCheck", "type": "str"}, + "columns_to_check": {"key": "columnsToCheck", "type": "[str]"}, + } + + def __init__(self, *, value_to_check: Optional[str] = None, columns_to_check: Optional[List[str]] = None, **kwargs): + """ + :keyword value_to_check: + :paramtype value_to_check: str + :keyword columns_to_check: + :paramtype columns_to_check: list[str] + """ + super(StringContainsRequest, self).__init__(**kwargs) + self.value_to_check = value_to_check + self.columns_to_check = columns_to_check + + +class StructuredInterfaceParameter(msrest.serialization.Model): + """StructuredInterfaceParameter. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar description: Required. + :vartype description: str + :ivar label: Required. + :vartype label: str + :ivar parameter_type: Required. Possible values include: "Int", "Double", "Bool", "String", + "Undefined". + :vartype parameter_type: str or ~index_service_apis.models.StructuredInterfaceParameterType + :ivar is_optional: Required. + :vartype is_optional: bool + :ivar default_value: Required. + :vartype default_value: str + :ivar lower_bound: Required. + :vartype lower_bound: str + :ivar upper_bound: Required. + :vartype upper_bound: str + :ivar enum_values: Required. + :vartype enum_values: list[str] + """ + + _validation = { + "name": {"required": True}, + "description": {"required": True}, + "label": {"required": True}, + "parameter_type": {"required": True}, + "is_optional": {"required": True}, + "default_value": {"required": True}, + "lower_bound": {"required": True}, + "upper_bound": {"required": True}, + "enum_values": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "description": {"key": "description", "type": "str"}, + "label": {"key": "label", "type": "str"}, + "parameter_type": {"key": "parameterType", "type": "str"}, + "is_optional": {"key": "isOptional", "type": "bool"}, + "default_value": {"key": "defaultValue", "type": "str"}, + "lower_bound": {"key": "lowerBound", "type": "str"}, + "upper_bound": {"key": "upperBound", "type": "str"}, + "enum_values": {"key": "enumValues", "type": "[str]"}, + } + + def __init__( + self, + *, + name: str, + description: str, + label: str, + parameter_type: Union[str, "StructuredInterfaceParameterType"], + is_optional: bool, + default_value: str, + lower_bound: str, + upper_bound: str, + enum_values: List[str], + **kwargs + ): + """ + :keyword name: Required. + :paramtype name: str + :keyword description: Required. + :paramtype description: str + :keyword label: Required. + :paramtype label: str + :keyword parameter_type: Required. Possible values include: "Int", "Double", "Bool", "String", + "Undefined". + :paramtype parameter_type: str or ~index_service_apis.models.StructuredInterfaceParameterType + :keyword is_optional: Required. + :paramtype is_optional: bool + :keyword default_value: Required. + :paramtype default_value: str + :keyword lower_bound: Required. + :paramtype lower_bound: str + :keyword upper_bound: Required. + :paramtype upper_bound: str + :keyword enum_values: Required. + :paramtype enum_values: list[str] + """ + super(StructuredInterfaceParameter, self).__init__(**kwargs) + self.name = name + self.description = description + self.label = label + self.parameter_type = parameter_type + self.is_optional = is_optional + self.default_value = default_value + self.lower_bound = lower_bound + self.upper_bound = upper_bound + self.enum_values = enum_values + + +class TimeDeltaDto(msrest.serialization.Model): + """TimeDeltaDto. + + All required parameters must be populated in order to send to Azure. + + :ivar days: Required. + :vartype days: int + :ivar hours: Required. + :vartype hours: int + :ivar minutes: Required. + :vartype minutes: int + """ + + _validation = { + "days": {"required": True}, + "hours": {"required": True}, + "minutes": {"required": True}, + } + + _attribute_map = { + "days": {"key": "days", "type": "int"}, + "hours": {"key": "hours", "type": "int"}, + "minutes": {"key": "minutes", "type": "int"}, + } + + def __init__(self, *, days: int, hours: int, minutes: int, **kwargs): + """ + :keyword days: Required. + :paramtype days: int + :keyword hours: Required. + :paramtype hours: int + :keyword minutes: Required. + :paramtype minutes: int + """ + super(TimeDeltaDto, self).__init__(**kwargs) + self.days = days + self.hours = hours + self.minutes = minutes + + +class TimestampColumnDto(msrest.serialization.Model): + """TimestampColumnDto. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar format: Required. + :vartype format: str + """ + + _validation = { + "name": {"required": True}, + "format": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "format": {"key": "format", "type": "str"}, + } + + def __init__(self, *, name: str, format: str, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword format: Required. + :paramtype format: str + """ + super(TimestampColumnDto, self).__init__(**kwargs) + self.name = name + self.format = format + + +class UnqueriableResourcesScope(msrest.serialization.Model): + """UnqueriableResourcesScope. + + :ivar resource_set: + :vartype resource_set: list[~index_service_apis.models.ResourceInformation] + """ + + _attribute_map = { + "resource_set": {"key": "resourceSet", "type": "[ResourceInformation]"}, + } + + def __init__(self, *, resource_set: Optional[List["ResourceInformation"]] = None, **kwargs): + """ + :keyword resource_set: + :paramtype resource_set: list[~index_service_apis.models.ResourceInformation] + """ + super(UnqueriableResourcesScope, self).__init__(**kwargs) + self.resource_set = resource_set + + +class Usage(msrest.serialization.Model): + """Usage. + + :ivar total_count: + :vartype total_count: long + """ + + _attribute_map = { + "total_count": {"key": "totalCount", "type": "long"}, + } + + def __init__(self, *, total_count: Optional[int] = None, **kwargs): + """ + :keyword total_count: + :paramtype total_count: long + """ + super(Usage, self).__init__(**kwargs) + self.total_count = total_count + + +class UserDto(msrest.serialization.Model): + """UserDto. + + All required parameters must be populated in order to send to Azure. + + :ivar user_object_id: Required. + :vartype user_object_id: str + :ivar user_tenant_id: Required. + :vartype user_tenant_id: str + :ivar user_name: Required. + :vartype user_name: str + """ + + _validation = { + "user_object_id": {"required": True}, + "user_tenant_id": {"required": True}, + "user_name": {"required": True}, + } + + _attribute_map = { + "user_object_id": {"key": "userObjectId", "type": "str"}, + "user_tenant_id": {"key": "userTenantId", "type": "str"}, + "user_name": {"key": "userName", "type": "str"}, + } + + def __init__(self, *, user_object_id: str, user_tenant_id: str, user_name: str, **kwargs): + """ + :keyword user_object_id: Required. + :paramtype user_object_id: str + :keyword user_tenant_id: Required. + :paramtype user_tenant_id: str + :keyword user_name: Required. + :paramtype user_name: str + """ + super(UserDto, self).__init__(**kwargs) + self.user_object_id = user_object_id + self.user_tenant_id = user_tenant_id + self.user_name = user_name + + +class UxPresenceResource(msrest.serialization.Model): + """UxPresenceResource. + + :ivar name: + :vartype name: str + :ivar resource_id: + :vartype resource_id: str + :ivar resource_type: + :vartype resource_type: str + :ivar region: + :vartype region: str + :ivar regions: + :vartype regions: list[~index_service_apis.models.ResourceRegion] + :ivar subscription_id: + :vartype subscription_id: str + :ivar resource_group_name: + :vartype resource_group_name: str + :ivar tags: A set of tags. Dictionary of :code:`<string>`. + :vartype tags: dict[str, str] + :ivar is_customer_managed: + :vartype is_customer_managed: bool + :ivar is_private_link_resource: + :vartype is_private_link_resource: bool + :ivar is_private_link_resource_behind_vnet: + :vartype is_private_link_resource_behind_vnet: bool + """ + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "resource_id": {"key": "resourceId", "type": "str"}, + "resource_type": {"key": "resourceType", "type": "str"}, + "region": {"key": "region", "type": "str"}, + "regions": {"key": "regions", "type": "[ResourceRegion]"}, + "subscription_id": {"key": "subscriptionId", "type": "str"}, + "resource_group_name": {"key": "resourceGroupName", "type": "str"}, + "tags": {"key": "tags", "type": "{str}"}, + "is_customer_managed": {"key": "isCustomerManaged", "type": "bool"}, + "is_private_link_resource": {"key": "isPrivateLinkResource", "type": "bool"}, + "is_private_link_resource_behind_vnet": {"key": "isPrivateLinkResourceBehindVnet", "type": "bool"}, + } + + def __init__( + self, + *, + name: Optional[str] = None, + resource_id: Optional[str] = None, + resource_type: Optional[str] = None, + region: Optional[str] = None, + regions: Optional[List["ResourceRegion"]] = None, + subscription_id: Optional[str] = None, + resource_group_name: Optional[str] = None, + tags: Optional[Dict[str, str]] = None, + is_customer_managed: Optional[bool] = None, + is_private_link_resource: Optional[bool] = None, + is_private_link_resource_behind_vnet: Optional[bool] = None, + **kwargs + ): + """ + :keyword name: + :paramtype name: str + :keyword resource_id: + :paramtype resource_id: str + :keyword resource_type: + :paramtype resource_type: str + :keyword region: + :paramtype region: str + :keyword regions: + :paramtype regions: list[~index_service_apis.models.ResourceRegion] + :keyword subscription_id: + :paramtype subscription_id: str + :keyword resource_group_name: + :paramtype resource_group_name: str + :keyword tags: A set of tags. Dictionary of :code:`<string>`. + :paramtype tags: dict[str, str] + :keyword is_customer_managed: + :paramtype is_customer_managed: bool + :keyword is_private_link_resource: + :paramtype is_private_link_resource: bool + :keyword is_private_link_resource_behind_vnet: + :paramtype is_private_link_resource_behind_vnet: bool + """ + super(UxPresenceResource, self).__init__(**kwargs) + self.name = name + self.resource_id = resource_id + self.resource_type = resource_type + self.region = region + self.regions = regions + self.subscription_id = subscription_id + self.resource_group_name = resource_group_name + self.tags = tags + self.is_customer_managed = is_customer_managed + self.is_private_link_resource = is_private_link_resource + self.is_private_link_resource_behind_vnet = is_private_link_resource_behind_vnet + + +class UxWarmUpRequest(msrest.serialization.Model): + """UxWarmUpRequest. + + :ivar entity_types: + :vartype entity_types: list[str] + :ivar resource_ids: + :vartype resource_ids: list[str] + """ + + _attribute_map = { + "entity_types": {"key": "entityTypes", "type": "[str]"}, + "resource_ids": {"key": "resourceIds", "type": "[str]"}, + } + + def __init__(self, *, entity_types: Optional[List[str]] = None, resource_ids: Optional[List[str]] = None, **kwargs): + """ + :keyword entity_types: + :paramtype entity_types: list[str] + :keyword resource_ids: + :paramtype resource_ids: list[str] + """ + super(UxWarmUpRequest, self).__init__(**kwargs) + self.entity_types = entity_types + self.resource_ids = resource_ids + + +class VersionedAttribute(msrest.serialization.Model): + """VersionedAttribute. + + All required parameters must be populated in order to send to Azure. + + :ivar name: Required. + :vartype name: str + :ivar version: Required. + :vartype version: str + """ + + _validation = { + "name": {"required": True}, + "version": {"required": True}, + } + + _attribute_map = { + "name": {"key": "name", "type": "str"}, + "version": {"key": "version", "type": "str"}, + } + + def __init__(self, *, name: str, version: str, **kwargs): + """ + :keyword name: Required. + :paramtype name: str + :keyword version: Required. + :paramtype version: str + """ + super(VersionedAttribute, self).__init__(**kwargs) + self.name = name + self.version = version + + +class Webhook(msrest.serialization.Model): + """Webhook. + + 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 webhook_type: Has constant value: "AzureDevOps". + :vartype webhook_type: str + :ivar event_type: Required. + :vartype event_type: str + """ + + _validation = { + "webhook_type": {"required": True, "constant": True}, + "event_type": {"required": True}, + } + + _attribute_map = { + "webhook_type": {"key": "webhookType", "type": "str"}, + "event_type": {"key": "eventType", "type": "str"}, + } + + webhook_type = "AzureDevOps" + + def __init__(self, *, event_type: str, **kwargs): + """ + :keyword event_type: Required. + :paramtype event_type: str + """ + super(Webhook, self).__init__(**kwargs) + self.event_type = event_type + + +class WorkspaceContextWarmUpRequest(msrest.serialization.Model): + """WorkspaceContextWarmUpRequest. + + :ivar discover_registries: + :vartype discover_registries: bool + """ + + _attribute_map = { + "discover_registries": {"key": "discoverRegistries", "type": "bool"}, + } + + def __init__(self, *, discover_registries: Optional[bool] = None, **kwargs): + """ + :keyword discover_registries: + :paramtype discover_registries: bool + """ + super(WorkspaceContextWarmUpRequest, self).__init__(**kwargs) + self.discover_registries = discover_registries diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/__init__.py new file mode 100644 index 00000000..19ac2fed --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/__init__.py @@ -0,0 +1,11 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from ._index_entities_operations import IndexEntitiesOperations + +__all__ = [ + "IndexEntitiesOperations", +] diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/_index_entities_operations.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/_index_entities_operations.py new file mode 100644 index 00000000..c00e58ca --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/operations/_index_entities_operations.py @@ -0,0 +1,151 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.6.2, generator: @autorest/python@5.12.6) +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from typing import TYPE_CHECKING + +from msrest import Serializer + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + map_error, +) +from azure.core.paging import ItemPaged +from azure.core.pipeline import PipelineResponse +from azure.core.pipeline.transport import HttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.mgmt.core.exceptions import ARMErrorFormat + +from .. import models as _models +from .._vendor import _convert_request + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any, Callable, Dict, Iterable, Optional, TypeVar + + T = TypeVar("T") + ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False +# fmt: off + +def build_get_entites_cross_region_request( + **kwargs # type: Any +): + # type: (...) -> HttpRequest + content_type = kwargs.pop('content_type', None) # type: Optional[str] + + accept = "application/json, text/json" + # Construct URL + _url = kwargs.pop("template_url", "/ux/v1.0/entities/crossRegion") + + # 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="POST", + url=_url, + headers=_header_parameters, + **kwargs + ) + + +# fmt: on +class IndexEntitiesOperations(object): + """IndexEntitiesOperations operations. + + You should not instantiate this class directly. Instead, you should create a Client instance that + instantiates it for you and attaches it as an attribute. + + :ivar models: Alias to model classes used in this operation group. + :type models: ~index_service_apis.models + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. + """ + + models = _models + + def __init__(self, client, config, serializer, deserializer): + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self._config = config + + @distributed_trace + def get_entites_cross_region( + self, + body=None, # type: Optional["_models.CrossRegionIndexEntitiesRequest"] + **kwargs # type: Any + ): + # type: (...) -> Iterable["_models.IndexEntitiesResponse"] + """get_entites_cross_region. + + :param body: + :type body: ~index_service_apis.models.CrossRegionIndexEntitiesRequest + :keyword callable cls: A custom type or function that will be passed the direct response + :return: An iterator like instance of either IndexEntitiesResponse or the result of + cls(response) + :rtype: ~azure.core.paging.ItemPaged[~index_service_apis.models.IndexEntitiesResponse] + :raises: ~azure.core.exceptions.HttpResponseError + """ + content_type = kwargs.pop("content_type", "application/json-patch+json") # type: Optional[str] + + cls = kwargs.pop("cls", None) # type: ClsType["_models.IndexEntitiesResponse"] + error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError} + error_map.update(kwargs.pop("error_map", {})) + + def prepare_request(next_link=None): + if body is not None: + body.index_entities_request.continuation_token = next_link + _json = self._serialize.body(body, "CrossRegionIndexEntitiesRequest") + else: + _json = None + + request = build_get_entites_cross_region_request( + content_type=content_type, + json=_json, + template_url=self.get_entites_cross_region.metadata["url"], + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) + + return request + + def extract_data(pipeline_response): + deserialized = self._deserialize( + "CrossRegionIndexEntitiesResponse", pipeline_response + ).index_entities_response + list_of_elem = deserialized.value + if cls: + list_of_elem = cls(list_of_elem) + return deserialized.continuation_token, iter(list_of_elem) + + def get_next(next_link=None): + request = prepare_request(next_link) + + pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access + request, stream=False, **kwargs + ) + 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) + + get_entites_cross_region.metadata = {"url": "/ux/v1.0/entities/crossRegion"} # type: ignore diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/py.typed b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/py.typed new file mode 100644 index 00000000..e5aff4f8 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_virtual_cluster_utils/_restclient/index_service_apis/py.typed @@ -0,0 +1 @@ +# Marker file for PEP 561.
\ No newline at end of file diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_workspace_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_workspace_utils.py new file mode 100644 index 00000000..fc6a3157 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/_workspace_utils.py @@ -0,0 +1,99 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +import logging +import random +import uuid + +from azure.ai.ml._azure_environments import _get_base_url_from_metadata, _resource_to_scopes +from azure.ai.ml._vendor.azure_resources._resource_management_client import ResourceManagementClient +from azure.ai.ml._vendor.azure_resources.models import GenericResource +from azure.ai.ml.constants._common import ArmConstants +from azure.core.credentials import TokenCredential + +module_logger = logging.getLogger(__name__) + + +def get_name_for_dependent_resource(workspace_name: str, resource_type: str) -> str: + alphabets_str = "" + for char in workspace_name.lower(): + if char.isalpha() or char.isdigit(): + alphabets_str = alphabets_str + char + rand_str = str(uuid.uuid4()).replace("-", "") + resource_name = alphabets_str[:8] + resource_type[:8] + rand_str + return resource_name[:24] + + +def get_deployment_name(name: str): + random.seed(version=2) + return f"{name}-{random.randint(1, 10000000)}" + + +def get_resource_group_location(credentials: TokenCredential, subscription_id: str, resource_group_name: str) -> str: + arm_hostname = _get_base_url_from_metadata() + client = ResourceManagementClient( + credential=credentials, + subscription_id=subscription_id, + base_url=arm_hostname, + api_version=ArmConstants.AZURE_MGMT_RESOURCE_API_VERSION, + credential_scopes=_resource_to_scopes(arm_hostname), + ) + rg = client.resource_groups.get(resource_group_name) + return rg.location + + +def get_generic_arm_resource_by_arm_id( + credentials: TokenCredential, + subscription_id: str, + arm_id: str, + api_version: str, +) -> GenericResource: + if arm_id: + arm_hostname = _get_base_url_from_metadata() + client = ResourceManagementClient( + credential=credentials, + subscription_id=subscription_id, + base_url=arm_hostname, + api_version=ArmConstants.AZURE_MGMT_RESOURCE_API_VERSION, + credential_scopes=_resource_to_scopes(arm_hostname), + ) + return client.resources.get_by_id(arm_id, api_version) + return None + + +def delete_resource_by_arm_id( + credentials: TokenCredential, + subscription_id: str, + arm_id: str, + api_version: str, +) -> None: + if arm_id: + arm_hostname = _get_base_url_from_metadata() + client = ResourceManagementClient( + credential=credentials, + subscription_id=subscription_id, + base_url=arm_hostname, + api_version=ArmConstants.AZURE_MGMT_RESOURCE_API_VERSION, + credential_scopes=_resource_to_scopes(arm_hostname), + ) + client.resources.begin_delete_by_id(arm_id, api_version) + + +def get_resource_and_group_name(armstr: str) -> str: + return armstr.split("/")[-1], armstr.split("/")[-5] + + +def get_sub_id_resource_and_group_name(armstr: str) -> str: + return armstr.split("/")[-7], armstr.split("/")[-1], armstr.split("/")[-5] + + +def get_endpoint_parts(arm_id: str, subnet_arm_id: str) -> (): + arm_id_parts = arm_id.split("/") + subnet_id_parts = subnet_arm_id.split("/") + conn_name = arm_id_parts[-1] + subscription_id = arm_id_parts[2] + resource_group = arm_id_parts[4] + vnet_name = subnet_id_parts[-3] + subnet_name = subnet_id_parts[-1] + return conn_name, subscription_id, resource_group, vnet_name, subnet_name diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/azure_resource_utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/azure_resource_utils.py new file mode 100644 index 00000000..c038b7d0 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/azure_resource_utils.py @@ -0,0 +1,79 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + + +from typing import Dict, List, Optional + +from azure.core.credentials import TokenCredential + +from .._vendor.azure_resources import ResourceManagementClient + + +def get_resources_from_subscriptions( + strQuery: str, credential: TokenCredential, subscription_list: Optional[List[str]] = None +): + # If a subscription list is passed in, use it. Otherwise, get all subscriptions + subsList = [] + if subscription_list is not None: + subsList = subscription_list + else: + try: + from azure.mgmt.resource import SubscriptionClient + except ImportError as e: + raise ImportError("azure-mgmt-resource is required to get all accessible subscriptions") from e + + subsClient = SubscriptionClient(credential) + for sub in subsClient.subscriptions.list(): + subsList.append(sub.as_dict().get("subscription_id")) + + try: + import azure.mgmt.resourcegraph as arg + except ImportError as e: + raise ImportError("azure-mgmt-resourcegraph is required query resources from subscriptions") from e + + # Create Azure Resource Graph client and set options + argClient = arg.ResourceGraphClient(credential) + argQueryOptions = arg.models.QueryRequestOptions(result_format="objectArray") + + # Create query + argQuery = arg.models.QueryRequest(subscriptions=subsList, query=strQuery, options=argQueryOptions) + + # Allowing API version to be set is yet to be released by azure-mgmt-resourcegraph, + # hence the commented out code below. This is the API version Studio UX is using. + # return argClient.resources(argQuery, api_version="2021-03-01") + + return argClient.resources(argQuery) + + +def get_virtual_clusters_from_subscriptions( + credential: TokenCredential, subscription_list: Optional[List[str]] = None +) -> List[Dict]: + # cspell:ignore tolower + strQuery = """resources + | where type == 'microsoft.machinelearningservices/virtualclusters' + | order by tolower(name) asc + | project id, subscriptionId, resourceGroup, name, location, tags, type""" + + return get_resources_from_subscriptions(strQuery, credential, subscription_list).data + + +def get_generic_resource_by_id( + arm_id: str, credential: TokenCredential, subscription_id: str, api_version: Optional[str] = None +) -> Dict: + resource_client = ResourceManagementClient(credential, subscription_id) + generic_resource = resource_client.resources.get_by_id(arm_id, api_version) + + return generic_resource.as_dict() + + +def get_virtual_cluster_by_name( + name: str, resource_group: str, subscription_id: str, credential: TokenCredential +) -> Dict: + arm_id = ( + f"/subscriptions/{subscription_id}/resourceGroups/{resource_group}" + f"/providers/Microsoft.MachineLearningServices/virtualClusters/{name}" + ) + + # This is the API version Studio UX is using. + return get_generic_resource_by_id(arm_id, credential, subscription_id, api_version="2021-03-01-preview") diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/utils.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/utils.py new file mode 100644 index 00000000..74b6352b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/_utils/utils.py @@ -0,0 +1,1429 @@ +# --------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# --------------------------------------------------------- + +# pylint: disable=protected-access,too-many-lines +import copy +import decimal +import hashlib +import json +import logging +import os +import random +import re +import string +import sys +import tempfile +import time +import warnings +from collections import OrderedDict +from contextlib import contextmanager, nullcontext +from datetime import timedelta +from functools import singledispatch, wraps +from os import PathLike +from pathlib import Path, PureWindowsPath +from typing import IO, Any, AnyStr, Callable, Dict, Iterable, List, Optional, Tuple, Union +from urllib.parse import urlparse +from uuid import UUID + +import isodate +import pydash +import yaml + +from azure.ai.ml._restclient.v2022_05_01.models import ListViewType, ManagedServiceIdentity +from azure.ai.ml._scope_dependent_operations import OperationScope +from azure.ai.ml._utils._http_utils import HttpPipeline +from azure.ai.ml.constants._common import ( + AZUREML_DISABLE_CONCURRENT_COMPONENT_REGISTRATION, + AZUREML_DISABLE_ON_DISK_CACHE_ENV_VAR, + AZUREML_INTERNAL_COMPONENTS_ENV_VAR, + AZUREML_INTERNAL_COMPONENTS_SCHEMA_PREFIX, + AZUREML_PRIVATE_FEATURES_ENV_VAR, + CommonYamlFields, + DefaultOpenEncoding, + WorkspaceDiscoveryUrlKey, +) +from azure.ai.ml.exceptions import MlException +from azure.core.pipeline.policies import RetryPolicy + +module_logger = logging.getLogger(__name__) + +DEVELOPER_URL_MFE_ENV_VAR = "AZUREML_DEV_URL_MFE" + +# Prefix used when hitting MFE skipping ARM +MFE_PATH_PREFIX = "/mferp/managementfrontend" + + +def _get_mfe_url_override() -> Optional[str]: + return os.getenv(DEVELOPER_URL_MFE_ENV_VAR) + + +def _is_https_url(url: str) -> Union[bool, str]: + if url: + return url.lower().startswith("https") + return False + + +def _csv_parser(text: Optional[str], convert: Callable) -> Optional[str]: + if not text: + return None + if "," in text: + return ",".join(convert(t.strip()) for t in text.split(",")) + + return convert(text) + + +def _snake_to_pascal_convert(text: str) -> str: + return string.capwords(text.replace("_", " ")).replace(" ", "") + + +def snake_to_pascal(text: Optional[str]) -> str: + """Convert snake name to pascal. + + :param text: String to convert + :type text: Optional[str] + :return: + * None if text is None + * Converted text from snake_case to PascalCase + :rtype: Optional[str] + """ + return _csv_parser(text, _snake_to_pascal_convert) + + +def snake_to_kebab(text: Optional[str]) -> Optional[str]: + """Convert snake name to kebab. + + :param text: String to convert + :type text: Optional[str] + :return: + * None if text is None + * Converted text from snake_case to kebab-case + :rtype: Optional[str] + """ + if text: + return re.sub("_", "-", text) + return None + + +# https://stackoverflow.com/questions/1175208 +# This works for pascal to snake as well +def _camel_to_snake_convert(text: str) -> str: + text = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", text) + return re.sub("([a-z0-9])([A-Z])", r"\1_\2", text).lower() + + +def camel_to_snake(text: str) -> Optional[str]: + """Convert camel name to snake. + + :param text: String to convert + :type text: str + :return: + * None if text is None + * Converted text from camelCase to snake_case + :rtype: Optional[str] + """ + return _csv_parser(text, _camel_to_snake_convert) + + +# This is snake to camel back which is different from snake to camel +# https://stackoverflow.com/questions/19053707 +def snake_to_camel(text: Optional[str]) -> Optional[str]: + """Convert snake name to camel. + + :param text: String to convert + :type text: Optional[str] + :return: + * None if text is None + * Converted text from snake_case to camelCase + :rtype: Optional[str] + """ + if text: + return re.sub("_([a-zA-Z0-9])", lambda m: m.group(1).upper(), text) + return None + + +# This is real snake to camel +def _snake_to_camel(name): + return re.sub(r"(?:^|_)([a-z])", lambda x: x.group(1).upper(), name) + + +def float_to_str(f): + """Convert a float to a string without scientific notation. + + :param f: Float to convert + :type f: float + :return: String representation of the float + :rtype: str + """ + with decimal.localcontext() as ctx: + ctx.prec = 20 # Support up to 20 significant figures. + float_as_dec = ctx.create_decimal(repr(f)) + return format(float_as_dec, "f") + + +def create_requests_pipeline_with_retry(*, requests_pipeline: HttpPipeline, retries: int = 3) -> HttpPipeline: + """Creates an HttpPipeline that reuses the same configuration as the supplied pipeline (including the transport), + but overwrites the retry policy. + + :keyword requests_pipeline: Pipeline to base new one off of. + :paramtype requests_pipeline: HttpPipeline + :keyword retries: Number of retries. Defaults to 3. + :paramtype retries: int + :return: Pipeline identical to provided one, except with a new retry policy + :rtype: HttpPipeline + """ + return requests_pipeline.with_policies(retry_policy=get_retry_policy(num_retry=retries)) + + +def get_retry_policy(num_retry: int = 3) -> RetryPolicy: + """Retrieves a retry policy to use in an azure.core.pipeline.Pipeline + + :param num_retry: The number of retries + :type num_retry: int + :return: Returns the msrest or requests REST client retry policy. + :rtype: RetryPolicy + """ + status_forcelist = [413, 429, 500, 502, 503, 504] + backoff_factor = 0.4 + return RetryPolicy( + retry_total=num_retry, + retry_read=num_retry, + retry_connect=num_retry, + retry_backoff_factor=backoff_factor, + retry_on_status_codes=status_forcelist, + ) + + +def download_text_from_url( + source_uri: str, + requests_pipeline: HttpPipeline, + timeout: Optional[Union[float, Tuple[float, float]]] = None, +) -> str: + """Downloads the content from an URL. + + :param source_uri: URI to download + :type source_uri: str + :param requests_pipeline: Used to send the request + :type requests_pipeline: HttpPipeline + :param timeout: One of + * float that specifies the connect and read time outs + * a 2-tuple that specifies the connect and read time out in that order + :type timeout: Union[float, Tuple[float, float]] + :return: The Response text + :rtype: str + """ + if not timeout: + timeout_params = {} + else: + connect_timeout, read_timeout = timeout if isinstance(timeout, tuple) else (timeout, timeout) + timeout_params = {"read_timeout": read_timeout, "connection_timeout": connect_timeout} + + response = requests_pipeline.get(source_uri, **timeout_params) + # Match old behavior from execution service's status API. + if response.status_code == 404: + return "" + + # _raise_request_error(response, "Retrieving content from " + uri) + return response.text() + + +def load_file(file_path: str) -> str: + """Load a local file. + + :param file_path: The relative or absolute path to the local file. + :type file_path: str + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if file or folder cannot be found. + :return: A string representation of the local file's contents. + :rtype: str + """ + from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException + + # These imports can't be placed in at top file level because it will cause a circular import in + # exceptions.py via _get_mfe_url_override + + try: + with open(file_path, "r", encoding=DefaultOpenEncoding.READ) as f: + cfg = f.read() + except OSError as e: # FileNotFoundError introduced in Python 3 + msg = "No such file or directory: {}" + raise ValidationException( + message=msg.format(file_path), + no_personal_data_message=msg.format("[file_path]"), + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND, + ) from e + return cfg + + +def load_json(file_path: Optional[Union[str, os.PathLike]]) -> Dict: + """Load a local json file. + + :param file_path: The relative or absolute path to the local file. + :type file_path: Union[str, os.PathLike] + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if file or folder cannot be found. + :return: A dictionary representation of the local file's contents. + :rtype: Dict + """ + from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException + + # These imports can't be placed in at top file level because it will cause a circular import in + # exceptions.py via _get_mfe_url_override + + try: + with open(file_path, "r", encoding=DefaultOpenEncoding.READ) as f: + cfg = json.load(f) + except OSError as e: # FileNotFoundError introduced in Python 3 + msg = "No such file or directory: {}" + raise ValidationException( + message=msg.format(file_path), + no_personal_data_message=msg.format("[file_path]"), + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND, + ) from e + return cfg + + +def load_yaml(source: Optional[Union[AnyStr, PathLike, IO]]) -> Dict: + # null check - just return an empty dict. + # Certain CLI commands rely on this behavior to produce a resource + # via CLI, which is then populated through CLArgs. + """Load a local YAML file. + + :param source: Either + * The relative or absolute path to the local file. + * A readable File-like object + :type source: Optional[Union[AnyStr, PathLike, IO]] + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if file or folder cannot be successfully loaded. + Details will be provided in the error message. + :return: A dictionary representation of the local file's contents. + :rtype: Dict + """ + from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException + + # These imports can't be placed in at top file level because it will cause a circular import in + # exceptions.py via _get_mfe_url_override + + if source is None: + return {} + + if isinstance(source, (str, os.PathLike)): + try: + cm = open(source, "r", encoding=DefaultOpenEncoding.READ) + except OSError as e: + msg = "No such file or directory: {}" + raise ValidationException( + message=msg.format(source), + no_personal_data_message=msg.format("[file_path]"), + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND, + ) from e + else: + # source is a subclass of IO + if not source.readable(): + msg = "File Permissions Error: The already-open \n\n inputted file is not readable." + raise ValidationException( + message=msg, + no_personal_data_message="File Permissions error", + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.INVALID_VALUE, + ) + + cm = nullcontext(enter_result=source) + + with cm as f: + try: + return yaml.safe_load(f) + except yaml.YAMLError as e: + msg = f"Error while parsing yaml file: {source} \n\n {str(e)}" + raise ValidationException( + message=msg, + no_personal_data_message="Error while parsing yaml file", + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.CANNOT_PARSE, + ) from e + + +# pylint: disable-next=docstring-missing-param +def dump_yaml(*args, **kwargs): + """A thin wrapper over yaml.dump which forces `OrderedDict`s to be serialized as mappings. + + Otherwise behaves identically to yaml.dump + + :return: The yaml object + :rtype: Any + """ + + class OrderedDumper(yaml.Dumper): + """A modified yaml serializer that forces pyyaml to represent an OrderedDict as a mapping instead of a + sequence.""" + + OrderedDumper.add_representer(OrderedDict, yaml.representer.SafeRepresenter.represent_dict) + return yaml.dump(*args, Dumper=OrderedDumper, **kwargs) + + +def dump_yaml_to_file( + dest: Optional[Union[AnyStr, PathLike, IO]], + data_dict: Union[OrderedDict, Dict], + default_flow_style=False, + args=None, # pylint: disable=unused-argument + **kwargs, +) -> None: + """Dump dictionary to a local YAML file. + + :param dest: The relative or absolute path where the YAML dictionary will be dumped. + :type dest: Optional[Union[AnyStr, PathLike, IO]] + :param data_dict: Dictionary representing a YAML object + :type data_dict: Union[OrderedDict, Dict] + :param default_flow_style: Use flow style for formatting nested YAML collections + instead of block style. Defaults to False. + :type default_flow_style: bool + :param path: Deprecated. Use 'dest' param instead. + :type path: Optional[Union[AnyStr, PathLike]] + :param args: Deprecated. + :type: Any + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if object cannot be successfully dumped. + Details will be provided in the error message. + """ + from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException + + # These imports can't be placed in at top file level because it will cause a circular import in + # exceptions.py via _get_mfe_url_override + # Check for deprecated path input, either named or as first unnamed input + path = kwargs.pop("path", None) + if dest is None: + if path is not None: + dest = path + warnings.warn( + "the 'path' input for dump functions is deprecated. Please use 'dest' instead.", DeprecationWarning + ) + else: + msg = "No dump destination provided." + raise ValidationException( + message=msg, + no_personal_data_message="No dump destination Provided", + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.MISSING_FIELD, + ) + + if isinstance(dest, (str, os.PathLike)): + try: + cm = open(dest, "w", encoding=DefaultOpenEncoding.WRITE) + except OSError as e: # FileNotFoundError introduced in Python 3 + msg = "No such parent folder path or not a file path: {}" + raise ValidationException( + message=msg.format(dest), + no_personal_data_message=msg.format("[file_path]"), + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.FILE_OR_FOLDER_NOT_FOUND, + ) from e + else: + # dest is a subclass of IO + if not dest.writable(): # dest is misformatted stream or file + msg = "File Permissions Error: The already-open \n\n inputted file is not writable." + raise ValidationException( + message=msg, + no_personal_data_message="File Permissions error", + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.CANNOT_PARSE, + ) + cm = nullcontext(enter_result=dest) + + with cm as f: + try: + dump_yaml(data_dict, f, default_flow_style=default_flow_style) + except yaml.YAMLError as e: + msg = f"Error while parsing yaml file \n\n {str(e)}" + raise ValidationException( + message=msg, + no_personal_data_message="Error while parsing yaml file", + error_category=ErrorCategory.USER_ERROR, + target=ErrorTarget.GENERAL, + error_type=ValidationErrorType.CANNOT_PARSE, + ) from e + + +def dict_eq(dict1: Dict[str, Any], dict2: Dict[str, Any]) -> bool: + """Compare two dictionaries. + + :param dict1: The first dictionary + :type dict1: Dict[str, Any] + :param dict2: The second dictionary + :type dict2: Dict[str, Any] + :return: True if the two dictionaries are equal, False otherwise + :rtype: bool + """ + if not dict1 and not dict2: + return True + return dict1 == dict2 + + +def xor(a: Any, b: Any) -> bool: + """XOR two values. + + :param a: The first value + :type a: Any + :param b: The second value + :type b: Any + :return: False if the two values are both True or both False, True otherwise + :rtype: bool + """ + return bool(a) != bool(b) + + +def is_url(value: Union[PathLike, str]) -> bool: + """Check if a string is a valid URL. + + :param value: The string to check + :type value: Union[PathLike, str] + :return: True if the string is a valid URL, False otherwise + :rtype: bool + """ + try: + result = urlparse(str(value)) + return all([result.scheme, result.netloc]) + except ValueError: + return False + + +# Resolve an URL to long form if it is an azureml short from datastore URL, otherwise return the same value +def resolve_short_datastore_url(value: Union[PathLike, str], workspace: OperationScope) -> str: + """Resolve an URL to long form if it is an azureml short from datastore URL, otherwise return the same value. + + :param value: The URL to resolve + :type value: Union[PathLike, str] + :param workspace: The workspace + :type workspace: OperationScope + :return: The resolved URL + :rtype: str + """ + from azure.ai.ml.exceptions import ValidationException + + # These imports can't be placed in at top file level because it will cause a circular import in + # exceptions.py via _get_mfe_url_override + + try: + # Check if the URL is an azureml URL + if urlparse(str(value)).scheme == "azureml": + from azure.ai.ml._utils._storage_utils import AzureMLDatastorePathUri + + data_store_path_uri = AzureMLDatastorePathUri(value) + if data_store_path_uri.uri_type == "Datastore": + return AzureMLDatastorePathUri(value).to_long_uri( + subscription_id=workspace.subscription_id, + resource_group_name=workspace.resource_group_name, + workspace_name=workspace.workspace_name, + ) + + except (ValueError, ValidationException): + pass + + # If the URL is not an valid URL (e.g. a local path) or not an azureml URL + # (e.g. a http URL), just return the same value + return value + + +def is_mlflow_uri(value: Union[PathLike, str]) -> bool: + """Check if a string is a valid mlflow uri. + + :param value: The string to check + :type value: Union[PathLike, str] + :return: True if the string is a valid mlflow uri, False otherwise + :rtype: bool + """ + try: + return urlparse(str(value)).scheme == "runs" + except ValueError: + return False + + +def validate_ml_flow_folder(path: str, model_type: string) -> None: + """Validate that the path is a valid ml flow folder. + + :param path: The path to validate + :type path: str + :param model_type: The model type + :type model_type: str + :return: No return value + :rtype: None + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the path is not a valid ml flow folder. + """ + from azure.ai.ml.exceptions import ErrorTarget, ValidationErrorType, ValidationException + + # These imports can't be placed in at top file level because it will cause a circular import in + # exceptions.py via _get_mfe_url_override + + if not isinstance(path, str): + path = path.as_posix() + path_array = path.split("/") + if model_type != "mlflow_model" or "." not in path_array[-1]: + return + msg = "Error with path {}. Model of type mlflow_model cannot register a file." + raise ValidationException( + message=msg.format(path), + no_personal_data_message=msg.format("[path]"), + target=ErrorTarget.MODEL, + error_type=ValidationErrorType.INVALID_VALUE, + ) + + +# modified from: https://stackoverflow.com/a/33245493/8093897 +def is_valid_uuid(test_uuid: str) -> bool: + """Check if a string is a valid UUID. + + :param test_uuid: The string to check + :type test_uuid: str + :return: True if the string is a valid UUID, False otherwise + :rtype: bool + """ + try: + uuid_obj = UUID(test_uuid, version=4) + except ValueError: + return False + return str(uuid_obj) == test_uuid + + +@singledispatch +def from_iso_duration_format(duration: Optional[Any] = None) -> int: # pylint: disable=unused-argument + """Convert ISO duration format to seconds. + + :param duration: The duration to convert + :type duration: Optional[Any] + :return: The converted duration + :rtype: int + """ + return None + + +@from_iso_duration_format.register(str) +def _(duration: str) -> int: + return int(isodate.parse_duration(duration).total_seconds()) + + +@from_iso_duration_format.register(timedelta) +def _(duration: timedelta) -> int: + return int(duration.total_seconds()) + + +def to_iso_duration_format_mins(time_in_mins: Optional[Union[int, float]]) -> str: + """Convert minutes to ISO duration format. + + :param time_in_mins: The time in minutes to convert + :type time_in_mins: Optional[Union[int, float]] + :return: The converted time in ISO duration format + :rtype: str + """ + return isodate.duration_isoformat(timedelta(minutes=time_in_mins)) if time_in_mins else None + + +def from_iso_duration_format_mins(duration: Optional[str]) -> int: + """Convert ISO duration format to minutes. + + :param duration: The duration to convert + :type duration: Optional[str] + :return: The converted duration + :rtype: int + """ + return int(from_iso_duration_format(duration) / 60) if duration else None + + +def to_iso_duration_format(time_in_seconds: Optional[Union[int, float]]) -> str: + """Convert seconds to ISO duration format. + + :param time_in_seconds: The time in seconds to convert + :type time_in_seconds: Optional[Union[int, float]] + :return: The converted time in ISO duration format + :rtype: str + """ + return isodate.duration_isoformat(timedelta(seconds=time_in_seconds)) if time_in_seconds else None + + +def to_iso_duration_format_ms(time_in_ms: Optional[Union[int, float]]) -> str: + """Convert milliseconds to ISO duration format. + + :param time_in_ms: The time in milliseconds to convert + :type time_in_ms: Optional[Union[int, float]] + :return: The converted time in ISO duration format + :rtype: str + """ + return isodate.duration_isoformat(timedelta(milliseconds=time_in_ms)) if time_in_ms else None + + +def from_iso_duration_format_ms(duration: Optional[str]) -> int: + """Convert ISO duration format to milliseconds. + + :param duration: The duration to convert + :type duration: Optional[str] + :return: The converted duration + :rtype: int + """ + return from_iso_duration_format(duration) * 1000 if duration else None + + +def to_iso_duration_format_days(time_in_days: Optional[int]) -> str: + """Convert days to ISO duration format. + + :param time_in_days: The time in days to convert + :type time_in_days: Optional[int] + :return: The converted time in ISO duration format + :rtype: str + """ + return isodate.duration_isoformat(timedelta(days=time_in_days)) if time_in_days else None + + +@singledispatch +def from_iso_duration_format_days(duration: Optional[Any] = None) -> int: # pylint: disable=unused-argument + return None + + +@from_iso_duration_format_days.register(str) +def _(duration: str) -> int: + return int(isodate.parse_duration(duration).days) + + +@from_iso_duration_format_days.register(timedelta) +def _(duration: timedelta) -> int: + return int(duration.days) + + +def _get_base_urls_from_discovery_service( + workspace_operations: "WorkspaceOperations", workspace_name: str, requests_pipeline: HttpPipeline +) -> Dict[WorkspaceDiscoveryUrlKey, str]: + """Fetch base urls for a workspace from the discovery service. + + :param WorkspaceOperations workspace_operations: + :param str workspace_name: The name of the workspace + :param HttpPipeline requests_pipeline: An HTTP pipeline to make requests with + :returns: A dictionary mapping url types to base urls + :rtype: Dict[WorkspaceDiscoveryUrlKey,str] + """ + discovery_url = workspace_operations.get(workspace_name).discovery_url + + return json.loads( + download_text_from_url( + discovery_url, + create_requests_pipeline_with_retry(requests_pipeline=requests_pipeline), + ) + ) + + +def _get_mfe_base_url_from_discovery_service( + workspace_operations: Any, workspace_name: str, requests_pipeline: HttpPipeline +) -> str: + all_urls = _get_base_urls_from_discovery_service(workspace_operations, workspace_name, requests_pipeline) + return f"{all_urls[WorkspaceDiscoveryUrlKey.API]}{MFE_PATH_PREFIX}" + + +def _get_mfe_base_url_from_registry_discovery_service( + workspace_operations: Any, workspace_name: str, requests_pipeline: HttpPipeline +) -> str: + all_urls = _get_base_urls_from_discovery_service(workspace_operations, workspace_name, requests_pipeline) + return all_urls[WorkspaceDiscoveryUrlKey.API] + + +def _get_workspace_base_url(workspace_operations: Any, workspace_name: str, requests_pipeline: HttpPipeline) -> str: + all_urls = _get_base_urls_from_discovery_service(workspace_operations, workspace_name, requests_pipeline) + return all_urls[WorkspaceDiscoveryUrlKey.API] + + +def _get_mfe_base_url_from_batch_endpoint(endpoint: "BatchEndpoint") -> str: + return endpoint.scoring_uri.split("/subscriptions/")[0] + + +# Allows to use a modified client with a provided url +@contextmanager +def modified_operation_client(operation_to_modify, url_to_use): + """Modify the operation client to use a different url. + + :param operation_to_modify: The operation to modify + :type operation_to_modify: Any + :param url_to_use: The url to use + :type url_to_use: str + :return: The modified operation + :rtype: Any + """ + original_api_base_url = None + try: + # Modify the operation + if url_to_use: + original_api_base_url = operation_to_modify._client._base_url + operation_to_modify._client._base_url = url_to_use + yield + finally: + # Undo the modification + if original_api_base_url: + operation_to_modify._client._base_url = original_api_base_url + + +def from_iso_duration_format_min_sec(duration: Optional[str]) -> str: + """Convert ISO duration format to min:sec format. + + :param duration: The duration to convert + :type duration: Optional[str] + :return: The converted duration + :rtype: str + """ + return duration.split(".")[0].replace("PT", "").replace("M", "m ") + "s" + + +def hash_dict(items: Dict[str, Any], keys_to_omit: Optional[Iterable[str]] = None) -> str: + """Return hash GUID of a dictionary except keys_to_omit. + + :param items: The dict to hash + :type items: Dict[str, Any] + :param keys_to_omit: Keys to omit before hashing + :type keys_to_omit: Optional[Iterable[str]] + :return: The hash GUID of the dictionary + :rtype: str + """ + if keys_to_omit is None: + keys_to_omit = [] + items = pydash.omit(items, keys_to_omit) + # serialize dict with order so same dict will have same content + serialized_component_interface = json.dumps(items, sort_keys=True) + object_hash = hashlib.md5() # nosec + object_hash.update(serialized_component_interface.encode("utf-8")) + return str(UUID(object_hash.hexdigest())) + + +def convert_identity_dict( + identity: Optional[ManagedServiceIdentity] = None, +) -> ManagedServiceIdentity: + """Convert identity to the right format. + + :param identity: The identity to convert + :type identity: Optional[ManagedServiceIdentity] + :return: The converted identity + :rtype: ManagedServiceIdentity + """ + if identity: + if identity.type.lower() in ("system_assigned", "none"): + identity = ManagedServiceIdentity(type="SystemAssigned") + else: + if identity.user_assigned_identities: + if isinstance(identity.user_assigned_identities, dict): # if the identity is already in right format + return identity + ids = {} + for id in identity.user_assigned_identities: # pylint: disable=redefined-builtin + ids[id["resource_id"]] = {} + identity.user_assigned_identities = ids + identity.type = snake_to_camel(identity.type) + else: + identity = ManagedServiceIdentity(type="SystemAssigned") + return identity + + +def strip_double_curly(io_binding_val: str) -> str: + """Strip double curly brackets from a string. + + :param io_binding_val: The string to strip + :type io_binding_val: str + :return: The string with double curly brackets stripped + :rtype: str + """ + return io_binding_val.replace("${{", "").replace("}}", "") + + +def append_double_curly(io_binding_val: str) -> str: + """Append double curly brackets to a string. + + :param io_binding_val: The string to append to + :type io_binding_val: str + :return: The string with double curly brackets appended + :rtype: str + """ + return f"${{{{{io_binding_val}}}}}" + + +def map_single_brackets_and_warn(command: str) -> str: + """Map single brackets to double brackets and warn if found. + + :param command: The command to map + :type command: str + :return: The mapped command + :rtype: str + """ + + def _check_for_parameter(param_prefix: str, command_string: str) -> Tuple[bool, str]: + template_prefix = r"(?<!\{)\{" + template_suffix = r"\.([^}]*)\}(?!\})" + template = template_prefix + param_prefix + template_suffix + should_warn = False + if bool(re.search(template, command_string)): + should_warn = True + command_string = re.sub(template, r"${{" + param_prefix + r".\g<1>}}", command_string) + return (should_warn, command_string) + + input_warn, command = _check_for_parameter("inputs", command) + output_warn, command = _check_for_parameter("outputs", command) + sweep_warn, command = _check_for_parameter("search_space", command) + if input_warn or output_warn or sweep_warn: + module_logger.warning("Use of {} for parameters is deprecated, instead use ${{}}.") + return command + + +def transform_dict_keys(data: Dict[str, Any], casing_transform: Callable[[str], str]) -> Dict[str, Any]: + """Convert all keys of a nested dictionary according to the passed casing_transform function. + + :param data: The data to transform + :type data: Dict[str, Any] + :param casing_transform: A callable applied to all keys in data + :type casing_transform: Callable[[str], str] + :return: A dictionary with transformed keys + :rtype: dict + """ + return { + casing_transform(key): transform_dict_keys(val, casing_transform) if isinstance(val, dict) else val + for key, val in data.items() + } + + +def merge_dict(origin, delta, dep=0) -> dict: + """Merge two dicts recursively. + Note that the function will return a copy of the origin dict if the depth of the recursion is 0. + + :param origin: The original dictionary + :type origin: dict + :param delta: The delta dictionary + :type delta: dict + :param dep: The depth of the recursion + :type dep: int + :return: The merged dictionary + :rtype: dict + """ + result = copy.deepcopy(origin) if dep == 0 else origin + for key, val in delta.items(): + origin_val = origin.get(key) + # Merge delta dict with original dict + if isinstance(origin_val, dict) and isinstance(val, dict): + result[key] = merge_dict(origin_val, val, dep + 1) + continue + result[key] = copy.deepcopy(val) + return result + + +def retry( + exceptions: Union[Tuple[Exception], Exception], + failure_msg: str, + logger: Any, + max_attempts: int = 1, + delay_multiplier: int = 0.25, +) -> Callable: + """Retry a function if it fails. + + :param exceptions: Exceptions to retry on. + :type exceptions: Union[Tuple[Exception], Exception] + :param failure_msg: Message to log on failure. + :type failure_msg: str + :param logger: Logger to use. + :type logger: Any + :param max_attempts: Maximum number of attempts. + :type max_attempts: int + :param delay_multiplier: Multiplier for delay between attempts. + :type delay_multiplier: int + :return: Decorated function. + :rtype: Callable + """ + + def retry_decorator(f): + @wraps(f) + def func_with_retries(*args, **kwargs): # pylint: disable=inconsistent-return-statements + tries = max_attempts + 1 + counter = 1 + while tries > 1: + delay = delay_multiplier * 2**counter + random.uniform(0, 1) + try: + return f(*args, **kwargs) + except exceptions as e: + tries -= 1 + counter += 1 + if tries == 1: + logger.warning(failure_msg) + raise e + logger.info(f"Operation failed. Retrying in {delay} seconds.") + time.sleep(delay) + + return func_with_retries + + return retry_decorator + + +def get_list_view_type(include_archived: bool, archived_only: bool) -> ListViewType: + """Get the list view type based on the include_archived and archived_only flags. + + :param include_archived: Whether to include archived items. + :type include_archived: bool + :param archived_only: Whether to only include archived items. + :type archived_only: bool + :return: The list view type. + :rtype: ListViewType + """ + if include_archived and archived_only: + msg = "Cannot provide both archived-only and include-archived." + raise MlException(message=msg, no_personal_data_message=msg) + if include_archived: + return ListViewType.ALL + if archived_only: + return ListViewType.ARCHIVED_ONLY + return ListViewType.ACTIVE_ONLY + + +def is_data_binding_expression( + value: str, binding_prefix: Union[str, List[str]] = "", is_singular: bool = True +) -> bool: + """Check if a value is a data-binding expression with specific binding target(prefix). Note that the function will + return False if the value is not a str. For example, if binding_prefix is ["parent", "jobs"], then input_value is a + data-binding expression only if the binding target starts with "parent.jobs", like "${{parent.jobs.xxx}}" if + is_singular is False, return True even if input_value includes non-binding part or multiple binding targets, like + "${{parent.jobs.xxx}}_extra" and "${{parent.jobs.xxx}}_{{parent.jobs.xxx}}". + + :param value: Value to check. + :type value: str + :param binding_prefix: Prefix to check for. + :type binding_prefix: Union[str, List[str]] + :param is_singular: should the value be a singular data-binding expression, like "${{parent.jobs.xxx}}". + :type is_singular: bool + :return: True if the value is a data-binding expression, False otherwise. + :rtype: bool + """ + return len(get_all_data_binding_expressions(value, binding_prefix, is_singular)) > 0 + + +def get_all_data_binding_expressions( + value: str, binding_prefix: Union[str, List[str]] = "", is_singular: bool = True +) -> List[str]: + """Get all data-binding expressions in a value with specific binding target(prefix). Note that the function will + return an empty list if the value is not a str. + + :param value: Value to extract. + :type value: str + :param binding_prefix: Prefix to filter. + :type binding_prefix: Union[str, List[str]] + :param is_singular: should the value be a singular data-binding expression, like "${{parent.jobs.xxx}}". + :type is_singular: bool + :return: list of data-binding expressions. + :rtype: List[str] + """ + if isinstance(binding_prefix, str): + binding_prefix = [binding_prefix] + if isinstance(value, str): + target_regex = r"\$\{\{\s*(" + "\\.".join(binding_prefix) + r"\S*?)\s*\}\}" + if is_singular: + target_regex = "^" + target_regex + "$" + return re.findall(target_regex, value) + return [] + + +def is_private_preview_enabled(): + """Check if private preview features are enabled. + + :return: True if private preview features are enabled, False otherwise. + :rtype: bool + """ + return os.getenv(AZUREML_PRIVATE_FEATURES_ENV_VAR) in ["True", "true", True] + + +def is_bytecode_optimization_enabled(): + """Check if bytecode optimization is enabled: + 1) bytecode package is installed + 2) private preview is enabled + 3) python version is between 3.6 and 3.11 + + :return: True if bytecode optimization is enabled, False otherwise. + :rtype: bool + """ + try: + import bytecode # pylint: disable=unused-import + + return is_private_preview_enabled() and (3, 6) < sys.version_info < (3, 12) + except ImportError: + return False + + +def is_on_disk_cache_enabled(): + """Check if on-disk cache for component registrations in pipeline submission is enabled. + + :return: True if on-disk cache is enabled, False otherwise. + :rtype: bool + """ + return os.getenv(AZUREML_DISABLE_ON_DISK_CACHE_ENV_VAR) not in ["True", "true", True] + + +def is_concurrent_component_registration_enabled(): # pylint: disable=name-too-long + """Check if concurrent component registrations in pipeline submission is enabled. + + :return: True if concurrent component registration is enabled, False otherwise. + :rtype: bool + """ + return os.getenv(AZUREML_DISABLE_CONCURRENT_COMPONENT_REGISTRATION) not in ["True", "true", True] + + +def _is_internal_components_enabled(): + return os.getenv(AZUREML_INTERNAL_COMPONENTS_ENV_VAR) in ["True", "true", True] + + +def try_enable_internal_components(*, force=False) -> bool: + """Try to enable internal components for the current process. This is the only function outside _internal that + references _internal. + + :keyword force: Force enable internal components even if enabled before. + :type force: bool + :return: True if internal components are enabled, False otherwise. + :rtype: bool + """ + if _is_internal_components_enabled(): + from azure.ai.ml._internal import enable_internal_components_in_pipeline + + enable_internal_components_in_pipeline(force=force) + + return True + return False + + +def is_internal_component_data(data: Dict[str, Any], *, raise_if_not_enabled: bool = False) -> bool: + """Check if the data is an internal component data by checking schema url prefix. + + :param data: The data to check. + :type data: Dict[str, Any] + :keyword raise_if_not_enabled: Raise exception if the data is an internal component data but + internal components is not enabled. + :type raise_if_not_enabled: bool + :return: True if the data is an internal component data, False otherwise. + :rtype: bool + :raises ~azure.ai.ml.exceptions.ValidationException: Raised if the data is an internal component data but + internal components is not enabled. + """ + from azure.ai.ml.exceptions import ErrorCategory, ErrorTarget, ValidationErrorType, ValidationException + + # These imports can't be placed in at top file level because it will cause a circular import in + # exceptions.py via _get_mfe_url_override + + schema = data.get(CommonYamlFields.SCHEMA, None) + + if schema is None or not isinstance(schema, str): + return False + + if not schema.startswith(AZUREML_INTERNAL_COMPONENTS_SCHEMA_PREFIX): + return False + + if not _is_internal_components_enabled() and raise_if_not_enabled: + no_personal_data_message = ( + f"Internal components is a private feature in v2, please set environment variable " + f"{AZUREML_INTERNAL_COMPONENTS_ENV_VAR} to true to use it." + ) + msg = f"Detected schema url {schema}. {no_personal_data_message}" + raise ValidationException( + message=msg, + target=ErrorTarget.COMPONENT, + error_type=ValidationErrorType.INVALID_VALUE, + no_personal_data_message=no_personal_data_message, + error_category=ErrorCategory.USER_ERROR, + ) + + return True + + +def is_valid_node_name(name: str) -> bool: + """Check if `name` is a valid node name + + :param name: A node name + :type name: str + :return: Return True if the string is a valid Python identifier in lower ASCII range, False otherwise. + :rtype: bool + """ + return isinstance(name, str) and name.isidentifier() and re.fullmatch(r"^[a-z_][a-z\d_]*", name) is not None + + +def parse_args_description_from_docstring(docstring: str) -> Dict[str, str]: + """Return arg descriptions in docstring with google style. + + e.g. + docstring = + ''' + A pipeline with detailed docstring, including descriptions for inputs and outputs. + + In this pipeline docstring, there are descriptions for inputs and outputs + Input/Output descriptions can infer from descriptions here. + + Args: + job_in_path: a path parameter + job_in_number: a number parameter + with multi-line description + job_in_int (int): a int parameter + + Other docstring xxxxxx + random_key: random_value + ''' + + return dict: + args = { + 'job_in_path': 'a path parameter', + 'job_in_number': 'a number parameter with multi-line description', + 'job_in_int': 'a int parameter' + } + + :param docstring: A Google-style docstring + :type docstring: str + :return: A map of parameter names to parameter descriptions + :rtype: Dict[str, str] + """ + args = {} + if not isinstance(docstring, str): + return args + lines = [line.strip() for line in docstring.splitlines()] + for index, line in enumerate(lines): + if line.lower() == "args:": + args_region = lines[index + 1 :] + args_line_end = args_region.index("") if "" in args_region else len(args_region) + args_region = args_region[0:args_line_end] + while len(args_region) > 0 and ":" in args_region[0]: + arg_line = args_region[0] + colon_index = arg_line.index(":") + arg, description = ( + arg_line[0:colon_index].strip(), + arg_line[colon_index + 1 :].strip(), + ) + # handle case like "param (float) : xxx" + if "(" in arg: + arg = arg[0 : arg.index("(")].strip() + args[arg] = description + args_region.pop(0) + # handle multi-line description, assuming description has no colon inside. + while len(args_region) > 0 and ":" not in args_region[0]: + args[arg] += " " + args_region[0] + args_region.pop(0) + return args + + +def convert_windows_path_to_unix(path: Union[str, PathLike]) -> str: + """Convert a Windows path to a Unix path. + + :param path: A Windows path + :type path: Union[str, os.PathLike] + :return: A Unix path + :rtype: str + """ + return PureWindowsPath(path).as_posix() + + +def _is_user_error_from_status_code(http_status_code): + return 400 <= http_status_code < 500 + + +def _str_to_bool(s: str) -> bool: + """Converts a string to a boolean + + Can be used as a type for argument in argparse, return argument's boolean value according to it's literal value. + + :param s: The string to convert + :type s: str + :return: True if s is "true" (case-insensitive), otherwise returns False. + :rtype: bool + """ + if not isinstance(s, str): + return False + return s.lower() == "true" + + +def _is_user_error_from_exception_type(e: Optional[Exception]) -> bool: + """Determine whether if an exception is user error from it's exception type. + + :param e: An exception + :type e: Optional[Exception] + :return: True if exception is a user error + :rtype: bool + """ + # Connection error happens on user's network failure, should be user error. + # For OSError/IOError with error no 28: "No space left on device" should be sdk user error + return isinstance(e, (ConnectionError, KeyboardInterrupt)) or (isinstance(e, (IOError, OSError)) and e.errno == 28) + + +class DockerProxy: + """A proxy class for docker module. It will raise a more user-friendly error message if docker module is not + installed. + """ + + def __getattribute__(self, name: str) -> Any: + try: + import docker + + return getattr(docker, name) + except ModuleNotFoundError as e: + msg = "Please install docker in the current python environment with `pip install docker` and try again." + raise MlException(message=msg, no_personal_data_message=msg) from e + + +def get_all_enum_values_iter(enum_type: type) -> Iterable[Any]: + """Get all values of an enum type. + + :param enum_type: An "enum" (not necessary enum.Enum) + :type enum_type: Type + :return: An iterable of all of the attributes of `enum_type` + :rtype: Iterable[Any] + """ + for key in dir(enum_type): + if not key.startswith("_"): + yield getattr(enum_type, key) + + +def write_to_shared_file(file_path: Union[str, PathLike], content: str): + """Open file with specific mode and return the file object. + + :param file_path: Path to the file. + :type file_path: Union[str, os.PathLike] + :param content: Content to write to the file. + :type content: str + """ + with open(file_path, "w", encoding=DefaultOpenEncoding.WRITE) as f: + f.write(content) + + # share_mode means read/write for owner, group and others + share_mode, mode_mask = 0o666, 0o777 + if os.stat(file_path).st_mode & mode_mask != share_mode: + try: + os.chmod(file_path, share_mode) + except PermissionError: + pass + + +def _get_valid_dot_keys_with_wildcard_impl( + left_reversed_parts, root, *, validate_func=None, cur_node=None, processed_parts=None +) -> List[str]: + if len(left_reversed_parts) == 0: + if validate_func is None or validate_func(root, processed_parts): + return [".".join(processed_parts)] + return [] + + if cur_node is None: + cur_node = root + if not isinstance(cur_node, dict): + return [] + if processed_parts is None: + processed_parts = [] + + key: str = left_reversed_parts.pop() + result = [] + if key == "*": + for next_key in cur_node: + if not isinstance(next_key, str): + continue + processed_parts.append(next_key) + result.extend( + _get_valid_dot_keys_with_wildcard_impl( + left_reversed_parts, + root, + validate_func=validate_func, + cur_node=cur_node[next_key], + processed_parts=processed_parts, + ) + ) + processed_parts.pop() + elif key in cur_node: + processed_parts.append(key) + result = _get_valid_dot_keys_with_wildcard_impl( + left_reversed_parts, + root, + validate_func=validate_func, + cur_node=cur_node[key], + processed_parts=processed_parts, + ) + processed_parts.pop() + + left_reversed_parts.append(key) + return result + + +def get_valid_dot_keys_with_wildcard( + root: Dict[str, Any], + dot_key_wildcard: str, + *, + validate_func: Optional[Callable[[List[str], Dict[str, Any]], bool]] = None, +) -> List[str]: + """Get all valid dot keys with wildcard. Only "x.*.x" and "x.*" is supported for now. + + A valid dot key should satisfy the following conditions: + 1) It should be a valid dot key in the root node. + 2) It should satisfy the validation function. + + :param root: Root node. + :type root: Dict[str, Any] + :param dot_key_wildcard: Dot key with wildcard, e.g. "a.*.c". + :type dot_key_wildcard: str + :keyword validate_func: Validation function. It takes two parameters: the root node and the dot key parts. + If None, no validation will be performed. + :paramtype validate_func: Optional[Callable[[List[str], Dict[str, Any]], bool]] + :return: List of valid dot keys. + :rtype: List[str] + """ + left_reversed_parts = dot_key_wildcard.split(".")[::-1] + return _get_valid_dot_keys_with_wildcard_impl(left_reversed_parts, root, validate_func=validate_func) + + +def get_base_directory_for_cache() -> Path: + """Get the base directory for cache files. + + :return: The base directory for cache files. + :rtype: Path + """ + return Path(tempfile.gettempdir()).joinpath("azure-ai-ml") + + +def get_versioned_base_directory_for_cache() -> Path: + """Get the base directory for cache files of current version of azure-ai-ml. + Cache files of different versions will be stored in different directories. + + :return: The base directory for cache files of current version of azure-ai-ml. + :rtype: Path + """ + # import here to avoid circular import + from azure.ai.ml._version import VERSION + + return get_base_directory_for_cache().joinpath(VERSION) + + +# pylint: disable-next=name-too-long +def get_resource_and_group_name_from_resource_id(armstr: str) -> str: + if armstr.find("/") == -1: + return armstr, None + return armstr.split("/")[-1], armstr.split("/")[-5] + + +# pylint: disable-next=name-too-long +def get_resource_group_name_from_resource_group_id(armstr: str) -> str: + if armstr.find("/") == -1: + return armstr + return armstr.split("/")[-1] + + +def extract_name_and_version(azureml_id: str) -> Dict[str, str]: + """Extract name and version from azureml id. + + :param azureml_id: AzureML id. + :type azureml_id: str + :return: A dict of name and version. + :rtype: Dict[str, str] + """ + if not isinstance(azureml_id, str): + raise ValueError("azureml_id should be a string but got {}: {}.".format(type(azureml_id), azureml_id)) + if azureml_id.count(":") != 1: + raise ValueError("azureml_id should be in the format of name:version but got {}.".format(azureml_id)) + name, version = azureml_id.split(":") + return { + "name": name, + "version": version, + } + + +def _get_evaluator_properties(): + return {"is-promptflow": "true", "is-evaluator": "true"} + + +def _is_evaluator(properties: Dict[str, str]) -> bool: + return properties.get("is-evaluator") == "true" and properties.get("is-promptflow") == "true" |