azureml-registry-tools 0.1.0a1__tar.gz

azureml_registry_tools-0.1.0a1/LICENSE.txt

@@ -0,0 +1,13 @@
+This software is made available to you on the condition that you agree to
+[your agreement][1] governing your use of Azure.
+If you do not have an existing agreement governing your use of Azure, you agree that 
+your agreement governing use of Azure is the [Microsoft Online Subscription Agreement][2]
+(which incorporates the [Online Services Terms][3]).
+By using the software you agree to these terms. This software may collect data
+that is transmitted to Microsoft. Please see the [Microsoft Privacy Statement][4]
+to learn more about how Microsoft processes personal data.
+
+[1]: https://azure.microsoft.com/en-us/support/legal/
+[2]: https://azure.microsoft.com/en-us/support/legal/subscription-agreement/
+[3]: http://www.microsoftvolumelicensing.com/DocumentSearch.aspx?Mode=3&DocumentTypeId=46
+[4]: http://go.microsoft.com/fwlink/?LinkId=248681 

azureml_registry_tools-0.1.0a1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: azureml-registry-tools
+Version: 0.1.0a1
+Summary: AzureML Registry tools and CLI
+Author: Microsoft Corp
+License: https://aka.ms/azureml-sdk-license
+Requires-Python: >=3.9,<3.12
+License-File: LICENSE.txt
+Requires-Dist: azure-ai-ml<2.0
+Requires-Dist: azureml-assets<2.0
+Dynamic: author
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

azureml_registry_tools-0.1.0a1/azureml/__init__.py

@@ -0,0 +1,7 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""__init.py__."""
+
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

azureml_registry_tools-0.1.0a1/azureml/registry/__init__.py

@@ -0,0 +1,7 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""__init__.py."""
+
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

azureml_registry_tools-0.1.0a1/azureml/registry/_cli/__init__.py

@@ -0,0 +1,4 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+"""Registry CLI tooling."""

azureml_registry_tools-0.1.0a1/azureml/registry/_cli/repo2registry_cli.py

@@ -0,0 +1,97 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+import argparse
+import re
+from pathlib import Path
+
+from azureml.registry.tools.repo2registry_config import create_repo2registry_config
+from azureml.registry.tools.create_or_update_assets import create_or_update_assets
+
+
+def validate_json_extension(output_json_file_name) -> Path:
+    """Validate if output file name provided is a .json file."""
+    output_json_file_path = Path(output_json_file_name)
+    if not output_json_file_path.suffix == ".json":
+        raise argparse.ArgumentTypeError(f"--output-json arg {output_json_file_name} must have a .json extension")
+    return output_json_file_path
+
+
+def validate_repo2registry_cfg(cfg_file_name) -> Path:
+    """Validate if output file name provided is a .cfg file."""
+    cfg_file_path = Path(cfg_file_name)
+    if not cfg_file_path.suffix == ".cfg":
+        raise argparse.ArgumentTypeError(f"--repo2registry-config arg {cfg_file_name} must be a path to a .cfg file")
+    return cfg_file_path
+
+
+def validate_continue_on_asset_failure_bool_str(bool_arg) -> str:
+    """Validate if continue_on_asset_failure arg can be converted to a boolean."""
+    if bool_arg.lower() not in ("true", "false"):
+        raise argparse.ArgumentTypeError(f"--continue-on-asset-failure arg {bool_arg} must be a boolean (True or False)")
+
+    return bool_arg.capitalize()
+
+
+def main():
+    """Repo2Registry CLI tool."""
+    # Handle command-line args
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers(dest="command")
+
+    update_parser = subparsers.add_parser("update")
+    update_parser.add_argument("-i", "--input-dir", type=Path,
+                               help="Directory containing assets to create/update")
+    update_parser.add_argument("-c", "--repo2registry-config", type=validate_repo2registry_cfg,
+                               help="Config containing info of registry to publish to")
+    update_parser.add_argument("-o", "--output-json", type=validate_json_extension, required=True,
+                               help="Output JSON file to write create/update results")
+    update_parser.add_argument("-d", "--dry-run", action="store_true",
+                               help="Dry run, don't actually create/update assets", default=False)
+    update_parser.add_argument("-f", "--filter", type=re.compile,
+                               help="Regex pattern to select assets to create/update, in the format <type>/<name>/<version>")
+
+    update_parser.add_argument("--git", action="store_true",
+                               help="Use git commits to detect file changes", default=False)
+    update_parser.add_argument("-b", "--base-commit",
+                               help="Base git commit for finding file changes")
+    update_parser.add_argument("-t", "--target-commit",
+                               help="Target git commit for finding file changes")
+
+    config_parser = subparsers.add_parser("config")
+    config_parser.add_argument("--registry-name", type=str, required=True,
+                               help="Name of registry to create/update assets")
+    config_parser.add_argument("--subscription", type=str, required=True,
+                               help="Subscription id of registry")
+    config_parser.add_argument("-g", "--resource_group", type=str, required=True,
+                               help="Name of registry resource group")
+    config_parser.add_argument("-c", "--repo2registry-config", type=validate_repo2registry_cfg, default=Path("repo2registry.cfg"),
+                               help="Config to write info of registry to publish to. Defaults to repo2registry.cfg")
+    config_parser.add_argument("--continue-on-asset-failure", default="False", type=validate_continue_on_asset_failure_bool_str,
+                               help="Continue creating/updating remaining assets when asset creation/update fails. Defaults to False.")
+
+    args = parser.parse_args()
+
+    if args.command == "config":
+        create_repo2registry_config(registry_name=args.registry_name,
+                                    subscription=args.subscription,
+                                    resource_group=args.resource_group,
+                                    repo2registry_config_file_name=args.repo2registry_config,
+                                    continue_on_asset_failure=args.continue_on_asset_failure)
+    elif args.command == "update":
+        if (args.git or args.base_commit or args.target_commit) and not (args.git and args.base_commit and args.target_commit):
+            parser.error("When using git, --git, --base-commit, and --target-commit are all required.")
+        if args.dry_run:
+            print("Dry run option was selected. No assets will be created or updated.")
+
+        create_or_update_assets(input_dir=args.input_dir,
+                                repo2registry_config_file_name=args.repo2registry_config,
+                                output_json_file_name=args.output_json,
+                                base_commit=args.base_commit,
+                                target_commit=args.target_commit,
+                                asset_filter=args.filter,
+                                dry_run=args.dry_run)
+
+
+if __name__ == '__main__':
+    main()

azureml_registry_tools-0.1.0a1/azureml/registry/tools/__init__.py

@@ -0,0 +1,4 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+"""This module is for registry tooling."""

azureml_registry_tools-0.1.0a1/azureml/registry/tools/config.py

@@ -0,0 +1,117 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""Asset spec classes."""
+
+from enum import Enum
+from pathlib import Path
+from ruamel.yaml import YAML
+from typing import Union
+
+from azure.ai.ml import load_component, load_data, load_environment, load_model
+from azure.ai.ml.entities import Component, Data, Environment, Model
+
+FULL_ASSET_NAME_TEMPLATE = "{type}/{name}/{version}"
+
+
+class ValidationException(Exception):
+    """Validation errors."""
+
+
+class AssetType(Enum):
+    """Asset type."""
+
+    COMPONENT = 'component'
+    DATA = 'data'
+    ENVIRONMENT = 'environment'
+    MODEL = 'model'
+
+
+class AssetSpec:
+    """Asset spec."""
+
+    def __init__(self, file_name: str, asset_type: str):
+        """Asset spec init."""
+        with open(file_name) as f:
+            self._yaml = YAML().load(f)
+
+        self._file_name_with_path = Path(file_name)
+        self._file_name = Path(file_name).name
+        self._file_path = Path(file_name).parent
+
+        self._asset_type = asset_type
+        self._asset_obj = None
+        self._asset_obj_to_create_or_update = None
+        self._repo2registry_config = None
+
+        self._validate()
+
+        if self.type == AssetType.COMPONENT:
+            self._asset_obj = load_component(source=file_name)
+        elif self.type == AssetType.DATA:
+            self._asset_obj = load_data(source=file_name)
+        elif self.type == AssetType.ENVIRONMENT:
+            self._asset_obj = load_environment(source=file_name)
+        elif self.type == AssetType.MODEL:
+            self._asset_obj = load_model(source=file_name)
+
+        if self._asset_obj is None:
+            raise ValidationException(f"Asset type {self.type} is not supported")
+
+    def _validate(self):
+        """Validate asset spec."""
+        if self.version is None:
+            raise ValidationException("Version not found in spec. Please specify version.")
+
+    @property
+    def file_name(self) -> str:
+        """Name of config file."""
+        return self._file_name
+
+    @property
+    def file_name_with_path(self) -> Path:
+        """Location of config file."""
+        return self._file_name_with_path
+
+    @property
+    def file_path(self) -> Path:
+        """Directory containing config file."""
+        return self._file_path
+
+    @property
+    def type(self) -> AssetType:
+        """Asset type."""
+        return AssetType(self._asset_type)
+
+    @property
+    def name(self) -> str:
+        """Asset name."""
+        return self._yaml.get('name')
+
+    @property
+    def version(self) -> str:
+        """Asset version."""
+        version = self._yaml.get('version')
+        return str(version) if version is not None else None
+
+    @property
+    def full_name(self) -> str:
+        """Full asset name, including type and version."""
+        return FULL_ASSET_NAME_TEMPLATE.format(type=self.type.value, name=self.name, version=self.version)
+
+    @property
+    def asset_obj(self) -> Union[Component, Data, Environment, Model]:
+        """Asset loaded using load_*(component, data, environment, model) method."""
+        return self._asset_obj
+
+    @property
+    def asset_obj_to_create_or_update(self) -> Union[Component, Data, Environment, Model]:
+        """Asset to create_or_update."""
+        if self._asset_obj_to_create_or_update:
+            return self._asset_obj_to_create_or_update
+        return self._asset_obj
+
+    def set_asset_obj_to_create_or_update(self, asset_obj):
+        """Set asset to create_or_update."""
+        self._asset_obj_to_create_or_update = asset_obj

azureml_registry_tools-0.1.0a1/azureml/registry/tools/create_or_update_assets.py

@@ -0,0 +1,326 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""Create or update assets."""
+
+import azure
+import json
+import os
+import re
+import tempfile
+import yaml
+from git import InvalidGitRepositoryError, Repo
+from pathlib import Path
+from typing import List, Union
+
+from azure.ai.ml import MLClient, load_data, load_model
+from azure.ai.ml.entities._assets._artifacts.data import Data
+from azure.ai.ml.entities._assets._artifacts.model import Model
+from azure.identity import DefaultAzureCredential
+import azureml.assets as assets
+
+from azureml.registry.tools.config import AssetType, AssetSpec
+from azureml.registry.tools.registry_utils import RegistryUtils
+from azureml.registry.tools.repo2registry_config import Repo2RegistryConfig
+
+
+def get_diff_files(base_commit: str,
+                   target_commit: str) -> List[str]:
+    """Run git diff to compare changes from base to target commit.
+
+    Args:
+        base_commit (str): Commit to be compared against.
+        target_commit (str): Commit to be compared to the base_commit.
+
+    Returns:
+        List[str]: Names of files changed from base to target commit.
+    """
+    print("Base and/or target commit argument(s) provided, checking for Github repository.")
+    try:
+        repo = Repo(".", search_parent_directories=True)
+    except InvalidGitRepositoryError as e:
+        raise Exception(f"Could not find a repository in current or parent directories: {e}")
+
+    print(f"Found .git folder: {Path(repo.git_dir).as_posix()}")
+
+    repo.git.execute(["git", "fetch", "origin"])
+
+    base_commit_type = repo.git.execute(["git", "cat-file", "-t", base_commit])
+    target_commit_type = repo.git.execute(["git", "cat-file", "-t", target_commit])
+
+    # Validate type of both commit arguments
+    if base_commit_type != "commit":
+        raise Exception(f"Base commit argument {base_commit} is an invalid commit")
+    if target_commit_type != "commit":
+        raise Exception(f"Target commit argument {target_commit} is an invalid commit")
+
+    print("Finding changed files using git diff")
+    diff_files = repo.git.execute(["git", "diff", base_commit, target_commit, "--name-only"])
+
+    # Each file in diff_files is relative to parent directory of the .git dir
+    parent_dir = os.path.abspath(os.path.join(repo.git_dir, ".."))
+    diff_files = diff_files.split("\n")
+    diff_files = [Path(parent_dir, f).as_posix() for f in diff_files]
+
+    return diff_files
+
+
+def find_assets(input_dir: Path,
+                base_commit: str = None,
+                target_commit: str = None,
+                asset_filter: re.Pattern = None) -> List[assets.AssetConfig]:
+    """Search directories for assets.
+
+    Args:
+        input_dir (Path): Directory to search in.
+        base_commit (str): Commit to be compared against for detecting file changes.
+        target_commit (str): Commit to be compared to the base_commit for detecting file changes.
+        asset_filter (re.Pattern): Regex pattern used to filter assets.
+    """
+    filename_pattern = re.compile(r'(environment|component|model|data)\.yaml$')
+    found_assets = []
+    found_changed_file = False
+
+    # Only if there's a base/target commit, check the git diff
+    changed_files = get_diff_files(base_commit, target_commit) if base_commit or target_commit else None
+    if changed_files == []:
+        print("No changed files found using git diff")
+        return []
+
+    print(f"Finding assets inside {input_dir}")
+
+    for file in input_dir.rglob("*.yaml"):
+        resolved_file = Path(file.resolve()).as_posix()
+        is_changed_file = resolved_file in changed_files if changed_files else None
+        filename_match = filename_pattern.match(file.name)
+
+        if filename_match:
+            if is_changed_file is False:
+                continue
+            found_changed_file = True
+            try:
+                asset_spec = AssetSpec(file, filename_match.group(1))
+            except Exception as e:
+                raise Exception(f"Failed to create AssetSpec object for {resolved_file}: {e}")
+
+            if asset_filter is not None and not asset_filter.fullmatch(asset_spec.full_name):
+                continue
+
+            found_assets.append(asset_spec)
+
+    if asset_filter and len(found_assets) == 0 and found_changed_file:
+        print(f"No assets found with the asset filter {asset_filter}. Please verify your filter regex can match assets with the format "
+              f"<type>/<name>/<version>, where asset type is component, data, environment, model.")
+    elif len(found_assets) == 0:
+        print("No assets were found.")
+    else:
+        print(f"Found assets: {[asset.full_name for asset in found_assets]}")
+
+    return found_assets
+
+
+def merge_yamls(existing_asset_file_name: str,
+                updated_asset_file_name: str) -> dict:
+    """Overwrite values from updated asset to existing asset with the exception of storage path.
+
+    Args:
+        existing_asset_file_name (str): Name of file containing details of asset currently in registry.
+        updated_asset_file_name (str): Name of file containing updated asset.
+
+    Returns:
+        dict: Merged asset data.
+    """
+    with open(existing_asset_file_name, "r") as existing_asset_file, open(updated_asset_file_name, "r") as updated_asset_file:
+        existing_asset_yaml = yaml.safe_load(existing_asset_file)
+        updated_asset_yaml = yaml.safe_load(updated_asset_file)
+    merged_asset = {**existing_asset_yaml, **updated_asset_yaml}
+    merged_asset["path"] = existing_asset_yaml["path"]
+
+    return merged_asset
+
+
+def merge_assets(existing_asset: Union[Data, Model],
+                 asset: AssetSpec):
+    """Overwrite values from updated to existing asset while preserving existing asset path.
+
+    Args:
+        existing_asset (Union[Data, Model]): Asset currently in registry.
+        asset (AssetSpec): AssetSpec containing updated asset info.
+    """
+    with tempfile.NamedTemporaryFile(suffix=".yaml", delete=False) as existing_asset_temp_file:
+        existing_asset_temp_file_name = existing_asset_temp_file.name
+
+    existing_asset.dump(existing_asset_temp_file_name)
+    merged_result = merge_yamls(existing_asset_temp_file_name, asset.file_name_with_path)
+
+    with tempfile.NamedTemporaryFile(suffix=".yaml", delete=False) as merged_asset_temp_file:
+        merged_asset_temp_file_name = merged_asset_temp_file.name
+
+    with open(merged_asset_temp_file_name, "w") as merged_asset_temp_file:
+        merged_asset_temp_file.write(yaml.dump(merged_result))
+
+    if asset.type == AssetType.MODEL:
+        merged_asset = load_model(merged_asset_temp_file_name)
+    elif asset.type == AssetType.DATA:
+        merged_asset = load_data(merged_asset_temp_file_name)
+
+    asset.set_asset_obj_to_create_or_update(merged_asset)
+
+    os.remove(existing_asset_temp_file_name)
+    os.remove(merged_asset_temp_file_name)
+
+
+def write_results(results_dict: dict,
+                  output_json_file_name: str,
+                  found_assets: List[AssetSpec],
+                  dry_run: bool):
+    """Write asset create/update results to JSON output file.
+
+    Args:
+        results_dict (dict): Results from asset create_or_update operations.
+        output_json_file_name (str): File name of JSON to write results to.
+        found_assets (List[AssetSpec]): List of assets found in input directories.
+        dry_run (bool): Dry run flag.
+    """
+    for asset in found_assets:
+        if asset.full_name not in results_dict:
+            if dry_run:
+                results_dict[asset.full_name] = {"DryRunCreateOrUpdateStatus": "NOT RUN", "Operation": "None", "Logs": ""}
+            else:
+                results_dict[asset.full_name] = {"CreateOrUpdateStatus": "NOT RUN", "Operation": "None", "Logs": ""}
+
+    # Produce JSON output on status and diffs
+    print("\nAsset create_or_update results:")
+    print(json.dumps(results_dict, indent=2))
+    with open(output_json_file_name, "w") as f:
+        json.dump(results_dict, f, indent=2)
+        print(f"Wrote asset create_or_update results to file {output_json_file_name}")
+
+
+def resolve_from_parent_folder(input_folder: Path) -> Path:
+    """Resolve repo2registry.cfg using parent folder.
+
+    Args:
+        input_folder (Path): Folder to check for repo2registry.cfg.
+
+    Returns:
+        Path: Folder containing repo2registry.cfg if found, otherwise None.
+    """
+    if os.path.exists(os.path.join(input_folder, "repo2registry.cfg")):
+        return input_folder
+    if os.path.abspath(input_folder) == os.path.abspath(os.sep):
+        return None
+    return resolve_from_parent_folder(os.path.dirname(input_folder))
+
+
+def create_or_update_assets(input_dir: Path,
+                            repo2registry_config_file_name: Path,
+                            output_json_file_name: Path,
+                            base_commit: str = None,
+                            target_commit: str = None,
+                            asset_filter: re.Pattern = None,
+                            dry_run: bool = False):
+    """Create or update assets.
+
+    Args:
+        input_dir (Path): Directory to search in.
+        repo2registry_config (Path): Config file containing registry info.
+        base_commit (str): Commit to be compared against for detecting file changes.
+        target_commit (str): Commit to be compared to the base_commit for detecting file changes.
+        output_json_file_name (Path): File name of JSON to write results to.
+        asset_filter (re.Pattern): Regex pattern used to filter assets.
+        dry_run (bool): Dry run flag.
+    """
+    if input_dir is None:
+        print(f"Input directory not specified, using current working directory: {os.getcwd()}")
+        input_dir = Path(os.getcwd())
+
+    if repo2registry_config_file_name is not None:
+        print(f"Using repo2registry.cfg file specified at path: {Path(repo2registry_config_file_name).resolve()} for all assets")
+        repo2registry_config = Repo2RegistryConfig(repo2registry_config_file_name)
+    else:
+        # If path to repo2registry.cfg file is unspecified, resolve cfg file starting at input_dir
+        print("No config file specified as an argument, resolving repo2registry.cfg file")
+
+        input_dir_abs_path = input_dir.resolve().as_posix()
+        repo2registry_config_folder = resolve_from_parent_folder(input_dir_abs_path)
+        if repo2registry_config_folder is None:
+            raise Exception(f"Could not find repo2registry.cfg file in any parent folders of {input_dir_abs_path}")
+
+        repo2registry_file_path = os.path.join(repo2registry_config_folder, 'repo2registry.cfg')
+        repo2registry_abs_file_path = Path(repo2registry_file_path).resolve().as_posix()
+        print(f"Found repo2registry.cfg file in {repo2registry_abs_file_path}")
+        repo2registry_config = Repo2RegistryConfig(repo2registry_file_path)
+
+    ml_client = MLClient(
+        subscription_id=repo2registry_config.subscription_id,
+        resource_group_name=repo2registry_config.resource_group,
+        registry_name=repo2registry_config.registry_name,
+        credential=DefaultAzureCredential(),
+    )
+
+    results_dict = {}
+    found_assets = find_assets(input_dir, base_commit, target_commit, asset_filter)
+
+    try:
+        for asset in found_assets:
+            print(f"\nPreparing {asset.full_name} for create/update")
+
+            # Check if asset/version has already been created
+            print(f"Attempting to find {asset.full_name} in {repo2registry_config.registry_name}")
+            existing_asset = None
+            try:
+                operations = RegistryUtils.get_operations_from_type(asset.type, ml_client=ml_client)
+                existing_asset = operations.get(name=asset.name, version=asset.version)
+                operation_str = "Update"
+                print(f"{asset.full_name} already exists. Preparing to {operation_str.upper()} asset.")
+            except azure.core.exceptions.ResourceNotFoundError:
+                operation_str = "Create"
+                print(f"{asset.full_name} does not exist. Preparing to {operation_str.upper()} asset.")
+            except Exception as e:
+                if dry_run:
+                    results_dict[asset.full_name] = {"DryRunCreateOrUpdateStatus": "NOT RUN", "Operation": "None", "Logs": f"{e}"}
+                else:
+                    results_dict[asset.full_name] = {"CreateOrUpdateStatus": "NOT RUN", "Operation": "None", "Logs": f"{e}"}
+                if repo2registry_config.continue_on_asset_failure:
+                    continue
+                else:
+                    raise
+
+            if existing_asset:
+                if asset.type == AssetType.MODEL or asset.type == AssetType.DATA:
+                    try:
+                        merge_assets(existing_asset, asset)
+                    except Exception as e:
+                        print(f"Failed to prepare {asset.full_name} for create_or_update: {e}")
+                        if dry_run:
+                            results_dict[asset.full_name] = {"DryRunCreateOrUpdateStatus": "NOT RUN", "Operation": f"{operation_str}", "Logs": f"{e}"}
+                        else:
+                            results_dict[asset.full_name] = {"CreateOrUpdateStatus": "NOT RUN", "Operation": f"{operation_str}", "Logs": f"{e}"}
+                        if repo2registry_config.continue_on_asset_failure:
+                            continue
+                        else:
+                            raise
+
+            try:
+                print(f"[{operation_str.upper()}] Running create_or_update on {asset.full_name}")
+                if not dry_run:
+                    operations.create_or_update(asset.asset_obj_to_create_or_update)
+                    print(f"Completed create_or_update for {asset.full_name}")
+                    results_dict[asset.full_name] = {"CreateOrUpdateStatus": "SUCCESS", "Operation": f"{operation_str}", "Logs": ""}
+                else:
+                    results_dict[asset.full_name] = {"DryRunCreateOrUpdateStatus": "SUCCESS", "Operation": f"{operation_str}", "Logs": ""}
+            except Exception as e:
+                print(f"Failed create_or_update for {asset.full_name}: {e}")
+                results_dict[asset.full_name] = {"CreateOrUpdateStatus": "FAILED", "Operation": f"{operation_str}", "Logs": f"{e}"}
+                if repo2registry_config.continue_on_asset_failure:
+                    continue
+                else:
+                    raise
+
+    except Exception:
+        write_results(results_dict, output_json_file_name, found_assets, dry_run)
+        raise Exception("Errors occurred while creating/updating assets")
+
+    write_results(results_dict, output_json_file_name, found_assets, dry_run)

azureml_registry_tools-0.1.0a1/azureml/registry/tools/registry_utils.py

@@ -0,0 +1,36 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""RegistryUtils class."""
+
+from typing import Union
+from azure.ai.ml import MLClient, operations as ops
+from azureml.registry.tools.config import AssetType
+
+
+class RegistryUtils:
+    """Registry utils."""
+
+    def get_operations_from_type(asset_type: AssetType, ml_client: MLClient) -> Union[
+                                 ops.ComponentOperations, ops.DataOperations, ops.EnvironmentOperations,
+                                 ops.ModelOperations]:
+        """Get MLCLient operations related to an asset type.
+
+        Args:
+            asset_type (AssetType): Asset type.
+            ml_client (MLClient): ML client.
+        Returns:
+            Union[ops.ComponentOperations, ops.DataOperations, ops.EnvironmentOperations,
+                ops.ModelOperations]: Operations object.
+        """
+        if asset_type == AssetType.COMPONENT:
+            return ml_client.components
+        elif asset_type == AssetType.DATA:
+            return ml_client.data
+        elif asset_type == AssetType.ENVIRONMENT:
+            return ml_client.environments
+        elif asset_type == AssetType.MODEL:
+            return ml_client.models
+        else:
+            raise Exception(f"Asset type {asset_type} is not supported.")

azureml_registry_tools-0.1.0a1/azureml/registry/tools/repo2registry_config.py

@@ -0,0 +1,108 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""Repo2RegistryConfig class."""
+
+import configparser
+from pathlib import Path
+
+
+class Repo2RegistryConfig:
+    """Repo2RegistryConfig class."""
+
+    def __init__(self, repo2registry_config_file_name: str):
+        """Repo2RegistryConfig init.
+
+        Args:
+            repo2registry_config_file (Path): Path of repo2registry config file.
+        """
+        if not Path(repo2registry_config_file_name).is_file():
+            raise FileNotFoundError(f"File '{repo2registry_config_file_name.resolve().as_posix()}' does not exist.")
+
+        config = configparser.ConfigParser()
+        config.read(repo2registry_config_file_name)
+
+        self._validate_schema(config, repo2registry_config_file_name)
+
+        self._subscription_id = config["registry"]["subscription_id"]
+        self._resource_group = config["registry"]["resource_group"]
+        self._registry_name = config["registry"]["registry_name"]
+        self._continue_on_asset_failure = self._get_bool_value(config["settings"]["continue_on_asset_failure"])
+
+    def _get_bool_value(self, value) -> bool:
+        return value.lower() == "true"
+
+    def _value_is_bool(self, value) -> bool:
+        return value.lower() in ("true", "false")
+
+    def _validate_schema(self, config, repo2registry_config_file_name):
+        """Validate repo2registry config schema."""
+        if not config.has_section("registry"):
+            raise Exception(f'"registry" section not found in config file {repo2registry_config_file_name}')
+        if not config.has_section("settings"):
+            raise Exception(f'"settings" section not found in config file {repo2registry_config_file_name}')
+
+        if not config.has_option("registry", "subscription_id"):
+            raise Exception(f'Key "subscription_id" not found under "registry" section in config file {repo2registry_config_file_name}')
+        if not config.has_option("registry", "resource_group"):
+            raise Exception(f'Key "resource_group" not found under "registry" section in config file {repo2registry_config_file_name}')
+        if not config.has_option("registry", "registry_name"):
+            raise Exception(f'Key "registry_name" not found under "registry" section in config file {repo2registry_config_file_name}')
+
+        if not config.has_option("settings", "continue_on_asset_failure"):
+            raise Exception(f'Key "continue_on_asset_failure" not found under "settings" section in config file {repo2registry_config_file_name}')
+        if not self._value_is_bool(config["settings"]["continue_on_asset_failure"]):
+            raise Exception(f'Key "continue_on_asset_failure" under "settings" section must be a boolean in config file {repo2registry_config_file_name}')
+
+    @property
+    def subscription_id(self) -> str:
+        """Subscription id."""
+        return self._subscription_id
+
+    @property
+    def resource_group(self) -> str:
+        """Resource group."""
+        return self._resource_group
+
+    @property
+    def registry_name(self) -> str:
+        """Registry name."""
+        return self._registry_name
+
+    @property
+    def continue_on_asset_failure(self) -> bool:
+        """Continue on asset failure."""
+        return self._continue_on_asset_failure
+
+
+def create_repo2registry_config(registry_name: str, subscription: str, resource_group: str, repo2registry_config_file_name: Path,
+                                continue_on_asset_failure: str):
+    """Create repo2registry config.
+
+    Args:
+        registry_name (str): Registry name.
+        subscription (str): Registry subscription id.
+        resource_group (str): Registry resource group.
+        repo2registry_config_file_name (Path): Path to config file.
+        continue_on_asset_failure (str): Whether to continue creating/updating remaining assets when asset creation/update fails.
+    """
+    print("Creating repo2registry config...")
+
+    repo2registry_config = configparser.ConfigParser()
+    repo2registry_config.add_section("registry")
+    repo2registry_config.set("registry", "registry_name", registry_name)
+    repo2registry_config.set("registry", "subscription_id", subscription)
+    repo2registry_config.set("registry", "resource_group", resource_group)
+
+    # Set default settings
+    repo2registry_config.add_section("settings")
+    repo2registry_config.set("settings", "continue_on_asset_failure", continue_on_asset_failure)
+
+    # Write to path
+    with open(repo2registry_config_file_name, "w") as repo2registry_config_file:
+        repo2registry_config.write(repo2registry_config_file)
+
+    repo2registry_cfg_abs_path = Path(repo2registry_config_file_name).resolve().as_posix()
+
+    print(f"Wrote repo2registry config file to {repo2registry_cfg_abs_path}")

azureml_registry_tools-0.1.0a1/azureml_registry_tools.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: azureml-registry-tools
+Version: 0.1.0a1
+Summary: AzureML Registry tools and CLI
+Author: Microsoft Corp
+License: https://aka.ms/azureml-sdk-license
+Requires-Python: >=3.9,<3.12
+License-File: LICENSE.txt
+Requires-Dist: azure-ai-ml<2.0
+Requires-Dist: azureml-assets<2.0
+Dynamic: author
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

azureml_registry_tools-0.1.0a1/azureml_registry_tools.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE.txt
+setup.cfg
+setup.py
+azureml/__init__.py
+azureml/registry/__init__.py
+azureml/registry/_cli/__init__.py
+azureml/registry/_cli/repo2registry_cli.py
+azureml/registry/tools/__init__.py
+azureml/registry/tools/config.py
+azureml/registry/tools/create_or_update_assets.py
+azureml/registry/tools/registry_utils.py
+azureml/registry/tools/repo2registry_config.py
+azureml_registry_tools.egg-info/PKG-INFO
+azureml_registry_tools.egg-info/SOURCES.txt
+azureml_registry_tools.egg-info/dependency_links.txt
+azureml_registry_tools.egg-info/entry_points.txt
+azureml_registry_tools.egg-info/requires.txt
+azureml_registry_tools.egg-info/top_level.txt

azureml_registry_tools-0.1.0a1/azureml_registry_tools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

azureml_registry_tools-0.1.0a1/azureml_registry_tools.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+repo2registry = azureml.registry._cli.repo2registry_cli:main

azureml_registry_tools-0.1.0a1/azureml_registry_tools.egg-info/requires.txt

@@ -0,0 +1,2 @@
+azure-ai-ml<2.0
+azureml-assets<2.0

azureml_registry_tools-0.1.0a1/azureml_registry_tools.egg-info/top_level.txt

@@ -0,0 +1 @@
+azureml

azureml_registry_tools-0.1.0a1/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+license_file = LICENSE.txt
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

azureml_registry_tools-0.1.0a1/setup.py

@@ -0,0 +1,30 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""Set up package."""
+
+from setuptools import setup, find_packages
+
+DEPENDENCIES = [
+    "azure-ai-ml<2.0",
+    "azureml-assets<2.0"
+]
+
+exclude_list = ["*.tests"]
+
+setup(
+    name='azureml-registry-tools',
+    version="0.1.0a1",
+    description='AzureML Registry tools and CLI',
+    author='Microsoft Corp',
+    license="https://aka.ms/azureml-sdk-license",
+    packages=find_packages(exclude=exclude_list),
+    install_requires=DEPENDENCIES,
+    python_requires=">=3.9,<3.12",
+    entry_points={
+        'console_scripts': [
+            'repo2registry = azureml.registry._cli.repo2registry_cli:main'
+        ],
+    }
+)