azureml-registry-tools 0.1.0a11__tar.gz → 0.1.0a13__tar.gz

{azureml_registry_tools-0.1.0a11/azureml_registry_tools.egg-info → azureml_registry_tools-0.1.0a13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: azureml-registry-tools
-Version: 0.1.0a11
+Version: 0.1.0a13
 Summary: AzureML Registry tools and CLI
 Author: Microsoft Corp
 License: https://aka.ms/azureml-sdk-license

{azureml_registry_tools-0.1.0a11 → azureml_registry_tools-0.1.0a13}/azureml/registry/_cli/registry_syndication_cli.py

@@ -6,13 +6,17 @@ import json
 import sys
 from pathlib import Path
 from uuid import UUID
-from azureml.registry._rest_client.registry_management_client import RegistryManagementClient
+
 from azureml.registry._rest_client.arm_client import ArmClient
-from azureml.registry.mgmt.asset_management import asset_validate, asset_deploy
+from azureml.registry._rest_client.registry_management_client import RegistryManagementClient
+from azureml.registry.mgmt.asset_management import asset_deploy, asset_validate
 from azureml.registry.mgmt.create_asset_template import asset_template
 from azureml.registry.mgmt.create_manifest import generate_syndication_manifest
+from azureml.registry.mgmt.model_management import (
+    model_delete, model_get, model_list, parse_asset_id
+)
 from azureml.registry.mgmt.registry_config import create_registry_config
-from azureml.registry.mgmt.syndication_manifest import SyndicationManifest, ResyncAssetsInManifestDto
+from azureml.registry.mgmt.syndication_manifest import ResyncAssetsInManifestDto, SyndicationManifest
 
 
 def syndication_manifest_show(registry_name: str) -> dict:
@@ -195,6 +199,36 @@ def main() -> None:
       # Create asset template files
       registry-mgmt asset template --folder ./folder-path
 
+      # List models in registry (auto-discover registry details: subscription/resource-group/primary-region)
+      registry-mgmt model list --registry-name myreg
+
+      # List models with explicit subscription, resource group, and primary region
+      registry-mgmt model list --registry-name myreg --subscription sub123 --resource-group rg123 --primary-region eastus
+
+      # Get a specific model by name and version (auto-discover registry details: subscription/resource-group/primary-region)
+      registry-mgmt model get --registry-name myreg --name mymodel --version 1
+
+      # Get a specific model with explicit subscription, resource group, and primary region
+      registry-mgmt model get --registry-name myreg --subscription sub123 --resource-group rg123 --primary-region eastus --name mymodel --version 1
+
+      # Get a model by asset ID (auto-discover registry details: subscription/resource-group/primary-region)
+      registry-mgmt model get --asset-id azureml://registries/myreg/models/mymodel/versions/1
+
+      # Delete a specific model version (auto-discover registry details: subscription/resource-group/primary-region)
+      registry-mgmt model delete --registry-name myreg --name mymodel --version 1
+
+      # Delete a specific model version with explicit subscription, resource group, and primary region
+      registry-mgmt model delete --registry-name myreg --subscription sub123 --resource-group rg123 --primary-region eastus --name mymodel --version 1
+
+      # Delete a model by asset ID (auto-discover registry details: subscription/resource-group/primary-region)
+      registry-mgmt model delete --asset-id azureml://registries/myreg/models/mymodel/versions/1
+
+      # Delete all versions of a model (auto-discover registry details: subscription/resource-group/primary-region)
+      registry-mgmt model delete --registry-name myreg --name mymodel --force
+
+      # Delete all versions of a model with explicit subscription, resource group, and primary region
+      registry-mgmt model delete --registry-name myreg --subscription sub123 --resource-group rg123 --primary-region eastus --name mymodel --force
+
       # Show registry discovery info
       registry-mgmt show --registry-name myreg
 
@@ -216,6 +250,52 @@ def main() -> None:
         }
     }
 
+    subscription_arg = {
+        "args": ("--subscription",),
+        "kwargs": {
+            "type": str,
+            "required": True,
+            "help": "Registry subscription ID."
+        }
+    }
+
+    resource_group_arg = {
+        "args": ("-g", "--resource-group"),
+        "kwargs": {
+            "type": str,
+            "required": True,
+            "help": "Registry resource group."
+        }
+    }
+
+    # Model-specific arguments (optional for registry auto-discovery)
+    model_subscription_arg = {
+        "args": ("--subscription",),
+        "kwargs": {
+            "type": str,
+            "required": False,
+            "help": "Registry subscription ID. If not provided, auto-resolves from registry discovery."
+        }
+    }
+
+    model_resource_group_arg = {
+        "args": ("-g", "--resource-group"),
+        "kwargs": {
+            "type": str,
+            "required": False,
+            "help": "Registry resource group. If not provided, auto-resolves from registry discovery."
+        }
+    }
+
+    model_primary_region_arg = {
+        "args": ("--primary-region",),
+        "kwargs": {
+            "type": str,
+            "required": False,
+            "help": "Registry primary region. If not provided, auto-resolves from registry discovery."
+        }
+    }
+
     dry_run_arg = {
         "args": ("--dry-run",),
         "kwargs": {
@@ -270,6 +350,8 @@ def main() -> None:
     asset_validate_parser = asset_subparsers.add_parser("validate", help="Validate an asset.")
     _add_common_args(asset_validate_parser, [dry_run_arg])
     asset_validate_parser.add_argument("--asset-path", type=Path, help="Path to the asset folder to validate.")
+    asset_validate_parser.add_argument("--allow-additional-properties", action="store_true",
+                                       help="Allow additional properties not defined in the schema")
 
     # asset deploy command
     asset_deploy_parser = asset_subparsers.add_parser("deploy", help="Deploy an asset to registry.")
@@ -279,9 +361,7 @@ def main() -> None:
 
     # asset config command
     asset_config_parser = asset_subparsers.add_parser("config", help="Create registry configuration file.")
-    asset_config_parser.add_argument("--registry-name", type=str, required=True, help="AzureML Registry name.")
-    asset_config_parser.add_argument("--subscription", type=str, required=True, help="Registry subscription ID.")
-    asset_config_parser.add_argument("-g", "--resource-group", type=str, required=True, help="Registry resource group.")
+    _add_common_args(asset_config_parser, [registry_name_arg, subscription_arg, resource_group_arg])
     asset_config_parser.add_argument("--tenant-id", type=str, required=True, help="Registry Tenant ID.")
     asset_config_parser.add_argument("-c", "--config-file", type=validate_registry_cfg, help="Registry config file path to write to (default: registry-mgmt.cfg).")
     asset_config_parser.add_argument("--storage-name", type=str, help="Storage account name for storage overrides.")
@@ -293,6 +373,42 @@ def main() -> None:
     _add_common_args(asset_template_parser, [dry_run_arg])
     asset_template_parser.add_argument("--folder", type=Path, required=True, help="Path to the folder where asset template files will be created.")
 
+    # model root command
+    model_parser = subparsers.add_parser("model", help="Model registry operations")
+    model_subparsers = model_parser.add_subparsers(dest="model_subcommand", required=True)
+
+    # model list command
+    model_list_parser = model_subparsers.add_parser("list", help="List models in the registry.")
+    _add_common_args(model_list_parser, [registry_name_arg, model_subscription_arg, model_resource_group_arg, model_primary_region_arg])
+    model_list_parser.add_argument("--name", type=str, help="Filter by model name.")
+    model_list_parser.add_argument("--tags", type=str, help="Comma separated string of tags key or tags key=value.")
+    model_list_parser.add_argument("--version", type=str, help="Filter by model version.")
+    model_list_parser.add_argument("--framework", type=str, help="Filter by framework.")
+    model_list_parser.add_argument("--description", type=str, help="Filter by description.")
+    model_list_parser.add_argument("--properties", type=str, help="Comma separated string of properties key and/or properties key=value.")
+    model_list_parser.add_argument("--run-id", type=str, help="Filter by runId which created the model.")
+    model_list_parser.add_argument("--dataset-id", type=str, help="Filter by datasetId associated with the model.")
+    model_list_parser.add_argument("--order-by", type=str, help="How the models are ordered in the response.")
+    model_list_parser.add_argument("--skip-token", type=str, help="The continuation token to retrieve the next page.")
+    model_list_parser.add_argument("--list-view-type", type=str, default="ActiveOnly", help="View type filter (default: ActiveOnly).")
+
+    # model get command
+    model_get_parser = model_subparsers.add_parser("get", help="Get a model by name and version, or by asset ID.")
+    _add_common_args(model_get_parser, [registry_name_arg, model_subscription_arg, model_resource_group_arg, model_primary_region_arg])
+    model_get_parser.add_argument("--asset-id", type=str, help="Model asset ID like azureml://registries/myRegistry/models/myModel/versions/1. When using asset-id, registry details are auto-discovered.")
+    model_get_parser.add_argument("--name", type=str, help="The name of the model.")
+    model_get_parser.add_argument("--version", type=str, help="The version of the model.")
+    model_get_parser.add_argument("--include-deployment-settings", action="store_true", help="Whether to include deployment settings.")
+    model_get_parser.add_argument("--workspace-id", type=str, help="Workspace ID GUID for deployment environment association.")
+
+    # model delete command
+    model_delete_parser = model_subparsers.add_parser("delete", help="Delete a model by name and version, or by asset ID.")
+    _add_common_args(model_delete_parser, [registry_name_arg, model_subscription_arg, model_resource_group_arg, model_primary_region_arg, dry_run_arg])
+    model_delete_parser.add_argument("--asset-id", type=str, help="Model asset ID like azureml://registries/myRegistry/models/myModel/versions/1. When using asset-id, registry details are auto-discovered.")
+    model_delete_parser.add_argument("--name", type=str, help="The name of the model to delete.")
+    model_delete_parser.add_argument("--version", type=str, help="The version to delete. If not specified, deletes all versions.")
+    model_delete_parser.add_argument("--force", action="store_true", help="Skip confirmation prompt.")
+
     # show root command
     show_parser = subparsers.add_parser("show", help="Show syndication info.")
     _add_common_args(show_parser, [registry_name_arg, dry_run_arg])
@@ -333,7 +449,7 @@ def main() -> None:
     elif args.command == "asset":
         if args.asset_subcommand == "validate":
             # Config file is not needed for validation
-            asset_validate(args.asset_path, args.dry_run)
+            asset_validate(args.asset_path, args.dry_run, args.allow_additional_properties)
         elif args.asset_subcommand == "deploy":
             # Config file is required for deployment
             asset_deploy(args.asset_path, args.config, args.dry_run)
@@ -356,6 +472,98 @@ def main() -> None:
         elif args.asset_subcommand == "template":
             # Create asset template files
             asset_template(args.folder, args.dry_run)
+    elif args.command == "model":
+        if args.model_subcommand == "list":
+            print(model_list(
+                registry_name=args.registry_name,
+                subscription_id=args.subscription,
+                resource_group_name=args.resource_group,
+                primary_region=args.primary_region,
+                name=args.name,
+                tags=args.tags,
+                version=args.version,
+                framework=args.framework,
+                description=args.description,
+                properties=args.properties,
+                run_id=args.run_id,
+                dataset_id=args.dataset_id,
+                order_by=args.order_by,
+                skip_token=args.skip_token,
+                list_view_type=args.list_view_type
+            ))
+        elif args.model_subcommand == "get":
+            # Validate that either asset_id is provided OR both name and version are provided
+            if args.asset_id:
+                if args.name or args.version:
+                    print("Error: Cannot use --asset-id with --name or --version", file=sys.stderr)
+                    sys.exit(1)
+                # Asset ID provided - auto-discover registry details
+                try:
+                    registry_name, model_name, version = parse_asset_id(args.asset_id)
+                except Exception as e:
+                    print(f"Error processing asset ID: {e}", file=sys.stderr)
+                    sys.exit(1)
+            else:
+                # Name/version provided - validate both are present
+                if not args.name or not args.version:
+                    print("Error: Both --name and --version are required when not using --asset-id", file=sys.stderr)
+                    sys.exit(1)
+                registry_name = args.registry_name
+                model_name = args.name
+                version = args.version
+
+            # Validate required parameters are not None
+            if not registry_name or not model_name or not version:
+                print("Error: Registry name, model name, and version must be provided", file=sys.stderr)
+                sys.exit(1)
+
+            # Single call to model_get with args values directly
+            print(model_get(
+                registry_name=registry_name,
+                name=model_name,
+                version=version,
+                subscription_id=args.subscription,
+                resource_group_name=args.resource_group,
+                primary_region=args.primary_region,
+                include_deployment_settings=args.include_deployment_settings,
+                workspace_id=args.workspace_id
+            ))
+        elif args.model_subcommand == "delete":
+            # Validate that either asset_id is provided OR name is provided
+            if args.asset_id:
+                if args.name:
+                    print("Error: Cannot use --asset-id with --name", file=sys.stderr)
+                    sys.exit(1)
+                # Asset ID provided - auto-discover registry details
+                try:
+                    registry_name, model_name, version = parse_asset_id(args.asset_id)
+                except Exception as e:
+                    print(f"Error processing asset ID: {e}", file=sys.stderr)
+                    sys.exit(1)
+            else:
+                if not args.name:
+                    print("Error: --name is required when not using --asset-id", file=sys.stderr)
+                    sys.exit(1)
+                registry_name = args.registry_name
+                model_name = args.name
+                version = args.version
+
+            # Validate required parameters are not None
+            if not registry_name or not model_name:
+                print("Error: Registry name and model name must be provided", file=sys.stderr)
+                sys.exit(1)
+
+            # Single call to model_delete with args values directly
+            model_delete(
+                registry_name=registry_name,
+                name=model_name,
+                version=version,
+                subscription_id=args.subscription,
+                resource_group_name=args.resource_group,
+                primary_region=args.primary_region,
+                dry_run=args.dry_run,
+                force=args.force
+            )
     elif args.command == "show":
         print(show_command(args.registry_name, args.as_arm_object))
     else:

azureml_registry_tools-0.1.0a13/azureml/registry/_rest_client/registry_model_client.py

@@ -0,0 +1,333 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from .base_rest_client import BaseAzureRestClient
+from .registry_management_client import RegistryManagementClient
+from json.decoder import JSONDecodeError
+from typing import Optional, Dict, Any
+
+DEFAULT_API_VERSION = "2025-04-01"
+
+
+class RegistryModelClient(BaseAzureRestClient):
+    """Python client for RegistryModelController.
+
+    Provides key operations for AzureML model management: get, list and, delete models.
+    """
+
+    def __init__(self, registry_name: str, subscription_id: str = None, resource_group_name: str = None,
+                 primary_region: str = None, api_key: str = None, max_retries: int = 5, backoff_factor: int = 1):
+        """
+        Initialize the RegistryModelClient.
+
+        Args:
+            registry_name (str): Name of the AzureML registry.
+            subscription_id (str, optional): Azure subscription ID. If None, auto-resolves from registry discovery.
+            resource_group_name (str, optional): Resource group name containing the registry. If None, auto-resolves from registry discovery.
+            primary_region (str, optional): Azure primary region for the registry. If None, auto-resolves from registry discovery.
+            api_key (str, optional): API key or bearer token. If None, uses DefaultAzureCredential.
+            max_retries (int): Maximum number of retries for requests.
+            backoff_factor (int): Backoff factor for retries.
+        """
+        # Auto-discover missing parameters using registry discovery
+        if subscription_id is None or resource_group_name is None or primary_region is None:
+            discovery = RegistryManagementClient(registry_name=registry_name).discovery()
+            discovered_subscription_id = discovery.get('subscriptionId')
+            discovered_resource_group = discovery.get('resourceGroup')
+            discovered_primary_region = discovery.get('primaryRegion')
+
+            # Validate that passed parameters match discovered ones
+            if subscription_id is not None and subscription_id != discovered_subscription_id:
+                raise ValueError(
+                    f"Provided subscription_id '{subscription_id}' does not match "
+                    f"discovered subscription_id '{discovered_subscription_id}' for registry '{registry_name}'"
+                )
+            if resource_group_name is not None and resource_group_name != discovered_resource_group:
+                raise ValueError(
+                    f"Provided resource_group_name '{resource_group_name}' does not match "
+                    f"discovered resource_group '{discovered_resource_group}' for registry '{registry_name}'"
+                )
+            if primary_region is not None and primary_region != discovered_primary_region:
+                raise ValueError(
+                    f"Provided primary_region '{primary_region}' does not match "
+                    f"discovered primary_region '{discovered_primary_region}' for registry '{registry_name}'"
+                )
+
+            # Use discovered values for any missing parameters
+            subscription_id = subscription_id or discovered_subscription_id
+            resource_group_name = resource_group_name or discovered_resource_group
+            primary_region = primary_region or discovered_primary_region
+
+        base_url = f"https://{primary_region}.api.azureml.ms"
+        super().__init__(base_url, api_key=api_key, max_retries=max_retries, backoff_factor=backoff_factor)
+
+        self.subscription_id = subscription_id
+        self.resource_group_name = resource_group_name
+        self.registry_name = registry_name
+
+        # Build the base path for model operations
+        self.base_path = (
+            f"/modelregistry/v1.0/subscriptions/{subscription_id}"
+            f"/resourceGroups/{resource_group_name}"
+            f"/providers/Microsoft.MachineLearningServices"
+            f"/registries/{registry_name}/models"
+        )
+
+    def list_models(self, name: str = None, tags: str = None, version: str = None,
+                    framework: str = None, description: str = None, properties: str = None,
+                    run_id: str = None, dataset_id: str = None, order_by: str = None,
+                    skip_token: str = None, list_view_type: str = "ActiveOnly",
+                    api_version: str = DEFAULT_API_VERSION, **kwargs) -> Dict[str, Any]:
+        """
+        Query the list of models in a registry.
+
+        Args:
+            name (str, optional): The model name.
+            tags (str, optional): Comma separated string of tags key or tags key=value.
+            version (str, optional): The model version.
+            framework (str, optional): The framework.
+            description (str, optional): The model description.
+            properties (str, optional): Comma separated string of properties key and/or properties key=value.
+            run_id (str, optional): The runId which created the model.
+            dataset_id (str, optional): The datasetId associated with the model.
+            order_by (str, optional): How the models are ordered in the response.
+            skip_token (str, optional): The continuation token to retrieve the next page.
+            list_view_type (str): View type filter (default: ActiveOnly).
+            api_version (str): The API version to use.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            Dict[str, Any]: Paged response containing list of models.
+        """
+        self._refresh_api_key_if_needed()
+
+        # Build query parameters
+        params = {"api-version": api_version, "listViewType": list_view_type}
+        if name:
+            params["name"] = name
+        if tags:
+            params["tags"] = tags
+        if version:
+            params["version"] = version
+        if framework:
+            params["framework"] = framework
+        if description:
+            params["description"] = description
+        if properties:
+            params["properties"] = properties
+        if run_id:
+            params["runId"] = run_id
+        if dataset_id:
+            params["datasetId"] = dataset_id
+        if order_by:
+            params["orderBy"] = order_by
+        if skip_token:
+            params["$skipToken"] = skip_token
+
+        url = f"{self.base_url}{self.base_path}"
+        response = self.get(url, params=params, **kwargs)
+
+        try:
+            return response.json()
+        except JSONDecodeError:
+            raise ValueError(f"Failed to decode JSON response from {url}: {response.text.strip()}")
+
+    # Method below is not currently used in the CLI, but kept for reference
+    def get_model_by_asset_id(self, asset_id_or_reference: str, include_deployment_settings: bool = False,
+                              workspace_id: str = None, api_version: str = DEFAULT_API_VERSION, **kwargs) -> Dict[str, Any]:
+        """
+        Get a model from registry using assetId or reference.
+
+        Args:
+            asset_id_or_reference (str): Model assetId like azureml://registries/myRegistry/models/myModel/versions/1.
+            include_deployment_settings (bool): Whether to include deployment settings.
+            workspace_id (str, optional): Workspace ID GUID for deployment environment association.
+            api_version (str): The API version to use.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            Dict[str, Any]: The model data.
+        """
+        self._refresh_api_key_if_needed()
+
+        # Use the alternate endpoint
+        url = f"{self.base_url}/modelregistry/v1.0/registry/models"
+
+        params = {
+            "assetIdOrReference": asset_id_or_reference,
+            "includeDeploymentSettings": str(include_deployment_settings).lower(),
+            "api-version": api_version
+        }
+        if workspace_id:
+            params["workspaceId"] = workspace_id
+
+        response = self.get(url, params=params, **kwargs)
+
+        try:
+            return response.json()
+        except JSONDecodeError:
+            raise ValueError(f"Failed to decode JSON response from {url}: {response.text.strip()}")
+
+    def get_model_by_name_and_version(self, name: str, version: str,
+                                      api_version: str = DEFAULT_API_VERSION, **kwargs) -> Dict[str, Any]:
+        """
+        Get a specific model by name and version from the registry.
+
+        Args:
+            name (str): The name of the model.
+            version (str): The version of the model.
+            api_version (str): The API version to use.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            Dict[str, Any]: The model data.
+
+        Raises:
+            ValueError: If name or version is not provided.
+        """
+        if not name or not version:
+            raise ValueError("Both name and version must be provided")
+
+        self._refresh_api_key_if_needed()
+
+        # Use the MMS ID format that the server expects: {name}:{version}
+        model_id = f"{name}:{version}"
+        url = f"{self.base_url}{self.base_path}/{model_id}"
+
+        response = self.get(url, **kwargs)
+
+        try:
+            return response.json()
+        except JSONDecodeError:
+            raise ValueError(f"Failed to decode JSON response from {url}: {response.text.strip()}")
+
+    def delete_model(self, name: str, version: str = None,
+                     api_version: str = DEFAULT_API_VERSION, **kwargs) -> Optional[Dict[str, Any]]:
+        """
+        Delete a model from the registry.
+
+        Args:
+            name (str): The name of the model to delete.
+            version (str, optional): The version to delete. If None, deletes all versions.
+            api_version (str): The API version to use.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            Optional[Dict[str, Any]]: The deletion response, if any.
+
+        Raises:
+            ValueError: If name is not provided.
+        """
+        if not name:
+            raise ValueError("name must be provided")
+
+        self._refresh_api_key_if_needed()
+
+        if version:
+            # Delete a specific version using the MMS ID format: {name}:{version}
+            model_id = f"{name}:{version}"
+            url = f"{self.base_url}{self.base_path}/{model_id}"
+            response = self.delete(url, **kwargs)
+
+            try:
+                return response.json()
+            except JSONDecodeError:
+                return response.text or None
+        else:
+            # Delete all versions: first list all versions, then delete each one
+            list_response = self.list_models(name=name, **kwargs)
+
+            if "value" not in list_response:
+                return {"message": f"No models found with name '{name}'"}
+
+            models = list_response["value"]
+            if not models:
+                return {"message": f"No models found with name '{name}'"}
+
+            deleted_versions = []
+            errors = []
+
+            for model in models:
+                try:
+                    model_version = model.get("properties", {}).get("version") or model.get("version")
+                    if model_version:
+                        # Delete this specific version
+                        model_id = f"{name}:{model_version}"
+                        url = f"{self.base_url}{self.base_path}/{model_id}"
+                        response = self.delete(url, **kwargs)
+
+                        if response.status_code in [200, 202, 204]:
+                            deleted_versions.append(model_version)
+                        else:
+                            errors.append(f"Failed to delete version {model_version}: {response.status_code}")
+                    else:
+                        errors.append(f"Could not determine version for model: {model}")
+                except Exception as e:
+                    errors.append(f"Error deleting model version: {str(e)}")
+
+            result = {
+                "message": f"Deleted {len(deleted_versions)} version(s) of model '{name}'",
+                "deleted_versions": deleted_versions
+            }
+
+            if errors:
+                result["errors"] = errors
+
+            return result
+
+    # Method below is not currently used in the CLI, but kept for reference
+    def get_model_for_non_azure_accounts(self, asset_id: str, api_version: str = DEFAULT_API_VERSION, **kwargs) -> Dict[str, Any]:
+        """
+        Get a model from registry for non-Azure accounts.
+
+        Args:
+            asset_id (str): Model assetId like azureml://registries/myRegistry/models/myModel/versions/1.
+            api_version (str): The API version to use.
+            **kwargs: Additional arguments for the request.
+
+        Returns:
+            Dict[str, Any]: The model data with SAS URL.
+        """
+        self._refresh_api_key_if_needed()
+
+        url = f"{self.base_url}/modelregistry/v1.0/registry/models/nonazureaccount"
+        params = {
+            "assetId": asset_id,
+            "api-version": api_version
+        }
+
+        response = self.get(url, params=params, **kwargs)
+
+        try:
+            return response.json()
+        except JSONDecodeError:
+            raise ValueError(f"Failed to decode JSON response from {url}: {response.text.strip()}")
+
+    @staticmethod
+    def parse_asset_id(asset_id: str) -> Dict[str, str]:
+        """
+        Parse an asset ID into its components.
+
+        Args:
+            asset_id (str): Model assetId like azureml://registries/myRegistry/models/myModel/versions/1.
+
+        Returns:
+            Dict[str, str]: Dictionary containing registry_name, name, and version.
+
+        Raises:
+            ValueError: If the asset ID format is invalid.
+        """
+        if not asset_id.startswith("azureml://registries/"):
+            raise ValueError("Asset ID must start with 'azureml://registries/'")
+
+        asset_id_parts = asset_id.split("/")
+        if len(asset_id_parts) < 8 or asset_id_parts[4] != "models" or asset_id_parts[6] != "versions":
+            raise ValueError(
+                "Invalid asset ID format. Expected: azureml://registries/myRegistry/models/myModel/versions/1"
+            )
+
+        return {
+            "registry_name": asset_id_parts[3],
+            "name": asset_id_parts[5],
+            "version": asset_id_parts[7]
+        }

{azureml_registry_tools-0.1.0a11 → azureml_registry_tools-0.1.0a13}/azureml/registry/data/validate_model_schema.py

@@ -2,37 +2,71 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
 
-"""Validate model variant schema."""
+"""Validate model schema."""
 
 import argparse
-import yaml
-import sys
 import jsonschema
+import sys
+import yaml
+
 from pathlib import Path
-from typing import List
+from typing import Any, Dict, List
 
 import azureml.assets as assets
 import azureml.assets.util as util
 from azureml.assets.util import logger
 
 
+def set_additional_properties_true(obj):
+    """Recursively set additionalProperties to True in a schema object."""
+    if isinstance(obj, dict):
+        if "additionalProperties" in obj:
+            obj["additionalProperties"] = True
+        for v in obj.values():
+            set_additional_properties_true(v)
+    elif isinstance(obj, list):
+        for item in obj:
+            set_additional_properties_true(item)
+
+
+def load_schema(schema_file: Path, allow_additional_properties: bool = False) -> Dict[str, Any]:
+    """Load and optionally modify the schema to allow for additional properties.
+
+    Args:
+        schema_file (Path): Path to the schema file
+        allow_additional_properties (bool): Whether to allow additional properties not defined in the schema
+
+    Returns:
+        dict: Loaded model schema
+    """
+    # Load schema from file
+    with open(schema_file, 'r') as file:
+        schema = yaml.safe_load(file)
+
+    if allow_additional_properties:
+        logger.print('Allowing for additional properties, setting "additionalProperties: true" in the model schema')
+        set_additional_properties_true(schema)
+
+    return schema
+
+
 def validate_model_schema(input_dirs: List[Path],
                           schema_file: Path,
-                          asset_config_filename: str) -> bool:
+                          asset_config_filename: str,
+                          allow_additional_properties: bool = False) -> bool:
     """Validate model variant schema.
 
     Args:
         input_dirs (List[Path]): Directories containing assets.
         schema_file (Path): File containing model variant schema.
         asset_config_filename (str): Asset config filename to search for.
+        allow_additional_properties (bool): Whether to allow additional properties not defined in schema.
 
     Returns:
         bool: True on success.
     """
     # Load model schema from file
-    loaded_schema = {}
-    with open(schema_file, 'r') as file:
-        loaded_schema = yaml.safe_load(file)
+    loaded_schema = load_schema(schema_file, allow_additional_properties)
 
     # Create validator instance for collecting all errors
     validator = jsonschema.Draft7Validator(loaded_schema)
@@ -99,12 +133,15 @@ def validate_model_schema(input_dirs: List[Path],
 
 if __name__ == "__main__":
     # Handle command-line args
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(description="Validate model specifications against JSON schema")
     parser.add_argument("-i", "--input-dirs", required=True,
                         help="Comma-separated list of directories containing assets")
-    parser.add_argument("-m", "--schema-file", default=Path(__file__).parent / "model.schema.json", type=Path, help="Model Schema file")
+    parser.add_argument("-m", "--schema-file", default=Path(__file__).parent / "model.schema.json", type=Path,
+                        help="Model Schema file")
     parser.add_argument("-a", "--asset-config-filename", default=assets.DEFAULT_ASSET_FILENAME,
                         help="Asset config file name to search for")
+    parser.add_argument("--allow-additional-properties", action="store_true",
+                        help="Allow additional properties not defined in the schema")
     args = parser.parse_args()
 
     # Convert comma-separated values to lists
@@ -113,7 +150,8 @@ if __name__ == "__main__":
     # Validate against model schema
     success = validate_model_schema(input_dirs=input_dirs,
                                     schema_file=args.schema_file,
-                                    asset_config_filename=args.asset_config_filename)
+                                    asset_config_filename=args.asset_config_filename,
+                                    allow_additional_properties=args.allow_additional_properties)
 
     if not success:
         sys.exit(1)

{azureml_registry_tools-0.1.0a11 → azureml_registry_tools-0.1.0a13}/azureml/registry/mgmt/asset_management.py

@@ -39,11 +39,12 @@ from azureml.assets.publish_utils import create_asset  # noqa: E402
 from azureml.assets.validate_assets import validate_assets  # noqa: E402
 
 
-def validate_model(asset_path: Path) -> bool:
+def validate_model(asset_path: Path, allow_additional_properties: bool = False) -> bool:
     """Validate model.
 
     Args:
         asset_path (Path): Path to the asset folder to validate
+        allow_additional_properties (bool): Whether to allow additional properties not defined in schema
 
     Returns:
         bool: True if validation passes, False otherwise
@@ -73,7 +74,8 @@ def validate_model(asset_path: Path) -> bool:
 
     print("⚙️ [VALIDATION #3]: Validating model schema...")
     if not validate_model_schema(input_dirs=[asset_path], schema_file=model_schema_file,
-                                 asset_config_filename=assets.DEFAULT_ASSET_FILENAME):
+                                 asset_config_filename=assets.DEFAULT_ASSET_FILENAME,
+                                 allow_additional_properties=allow_additional_properties):
         print("❌ [FAILED] Validation #3: validate_model_schema\n")
         errors += 1
     else:
@@ -193,12 +195,13 @@ def create_or_update_asset(readonly_asset: AssetConfig, config: RegistryConfig):
         print(f" - Azure Portal link: https://ml.azure.com/registries/{config.registry_name}/models/{mutable_asset.name}/version/{mutable_asset.version}?tid={config.tenant_id}")
 
 
-def asset_validate(asset_path: Path, dry_run: bool = False) -> bool:
+def asset_validate(asset_path: Path, dry_run: bool = False, allow_additional_properties: bool = False) -> bool:
     """Validate an asset at the specified path.
 
     Args:
         asset_path (Path): Path to the asset folder to validate
         dry_run (bool): If True, perform a dry run without side effects
+        allow_additional_properties (bool): Whether to allow additional properties not defined in schema
 
     Returns:
         bool: True if validation passes, False otherwise
@@ -231,7 +234,7 @@ def asset_validate(asset_path: Path, dry_run: bool = False) -> bool:
         return False
 
     # Perform validation
-    return validate_model(readonly_asset.file_path)
+    return validate_model(readonly_asset.file_path, allow_additional_properties)
 
 
 def asset_deploy(asset_path: Path, config_path: Path, dry_run: bool = False) -> bool:

azureml_registry_tools-0.1.0a13/azureml/registry/mgmt/model_management.py

@@ -0,0 +1,169 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+"""Model management methods."""
+import json
+import sys
+from typing import Tuple
+from azureml.registry._rest_client.registry_model_client import RegistryModelClient
+
+
+def parse_asset_id(asset_id: str) -> Tuple[str, str, str]:
+    """Parse an asset ID into its components.
+
+    Args:
+        asset_id (str): Model assetId like azureml://registries/myRegistry/models/myModel/versions/1.
+
+    Returns:
+        Tuple[str, str, str]: (registry_name, model_name, version)
+
+    Raises:
+        ValueError: If the asset ID format is invalid.
+    """
+    try:
+        parsed = RegistryModelClient.parse_asset_id(asset_id)
+        return parsed["registry_name"], parsed["name"], parsed["version"]
+    except ValueError as e:
+        raise ValueError(f"Invalid asset ID '{asset_id}': {e}")
+
+
+def model_list(registry_name: str, subscription_id: str = None, resource_group_name: str = None,
+               primary_region: str = None, name: str = None, tags: str = None,
+               version: str = None, framework: str = None, description: str = None,
+               properties: str = None, run_id: str = None, dataset_id: str = None,
+               order_by: str = None, skip_token: str = None, list_view_type: str = "ActiveOnly") -> str:
+    """List models in the registry.
+
+    Args:
+        registry_name (str): Name of the Azure ML registry.
+        subscription_id (str, optional): Azure subscription ID. If None, auto-resolves from registry discovery.
+        resource_group_name (str, optional): Resource group name containing the registry. If None, auto-resolves from registry discovery.
+        primary_region (str, optional): Azure primary region for the registry. If None, auto-resolves from registry discovery.
+        name (str, optional): The object name.
+        tags (str, optional): Comma separated string of tags key or tags key=value.
+        version (str, optional): The object version.
+        framework (str, optional): The framework.
+        description (str, optional): The object description.
+        properties (str, optional): Comma separated string of properties key and/or properties key=value.
+        run_id (str, optional): The runId which created the model.
+        dataset_id (str, optional): The datasetId associated with the model.
+        order_by (str, optional): How the models are ordered in the response.
+        skip_token (str, optional): The continuation token to retrieve the next page.
+        list_view_type (str): View type filter (default: ActiveOnly).
+
+    Returns:
+        str: JSON response containing list of models.
+    """
+    try:
+        client = RegistryModelClient(
+            registry_name=registry_name,
+            subscription_id=subscription_id,
+            resource_group_name=resource_group_name,
+            primary_region=primary_region
+        )
+
+        result = client.list_models(
+            name=name, tags=tags, version=version, framework=framework,
+            description=description, properties=properties, run_id=run_id,
+            dataset_id=dataset_id, order_by=order_by, skip_token=skip_token,
+            list_view_type=list_view_type
+        )
+
+        return json.dumps(result, indent=2)
+
+    except Exception as e:
+        print(f"Error listing models: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def model_get(registry_name: str, name: str, version: str,
+              subscription_id: str = None, resource_group_name: str = None,
+              primary_region: str = None, include_deployment_settings: bool = False, workspace_id: str = None) -> str:
+    """Get a specific model by name and version.
+
+    Args:
+        registry_name (str): Name of the Azure ML registry.
+        name (str): The name of the model.
+        version (str): The version of the model.
+        subscription_id (str, optional): Azure subscription ID. If None, auto-resolves from registry discovery.
+        resource_group_name (str, optional): Resource group name containing the registry. If None, auto-resolves from registry discovery.
+        primary_region (str, optional): Azure primary region for the registry. If None, auto-resolves from registry discovery.
+        include_deployment_settings (bool): Whether to include deployment settings.
+        workspace_id (str, optional): Workspace ID GUID for deployment environment association.
+
+    Returns:
+        str: JSON response containing the model data.
+    """
+    try:
+        client = RegistryModelClient(
+            registry_name=registry_name,
+            subscription_id=subscription_id,
+            resource_group_name=resource_group_name,
+            primary_region=primary_region
+        )
+
+        result = client.get_model_by_name_and_version(
+            name=name,
+            version=version
+        )
+
+        return json.dumps(result, indent=2)
+
+    except Exception as e:
+        print(f"Error getting model {name} version {version}: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def model_delete(registry_name: str, name: str, version: str = None,
+                 subscription_id: str = None, resource_group_name: str = None,
+                 primary_region: str = None, dry_run: bool = False, force: bool = False) -> None:
+    """Delete a model from the registry.
+
+    Args:
+        registry_name (str): Name of the Azure ML registry.
+        name (str): The name of the model to delete.
+        version (str, optional): The version to delete. If None, deletes all versions.
+        subscription_id (str, optional): Azure subscription ID. If None, auto-resolves from registry discovery.
+        resource_group_name (str, optional): Resource group name containing the registry. If None, auto-resolves from registry discovery.
+        primary_region (str, optional): Azure primary region for the registry. If None, auto-resolves from registry discovery.
+        dry_run (bool): If True, do not perform any changes.
+        force (bool): If True, skip confirmation prompt.
+    """
+    try:
+        if not force:
+            if version:
+                confirm = input(f"Are you sure you want to delete model '{name}' version '{version}' from registry '{registry_name}'? [y/N]: ")
+            else:
+                confirm = input(f"Are you sure you want to delete ALL versions of model '{name}' from registry '{registry_name}'? [y/N]: ")
+            if confirm.lower() != "y":
+                print("Model deletion cancelled.")
+                return
+
+        if dry_run:
+            if version:
+                print(f"Dry run: Would delete model {name} version {version}")
+            else:
+                print(f"Dry run: Would delete all versions of model {name}")
+            return
+
+        client = RegistryModelClient(
+            registry_name=registry_name,
+            subscription_id=subscription_id,
+            resource_group_name=resource_group_name,
+            primary_region=primary_region
+        )
+
+        result = client.delete_model(
+            name=name,
+            version=version
+        )
+        print(result)
+
+        if version:
+            print(f"Successfully deleted model '{name}' version '{version}'")
+        else:
+            print(f"Successfully deleted all versions of model '{name}'")
+
+    except Exception as e:
+        print(f"Error deleting model {name}: {e}", file=sys.stderr)
+        sys.exit(1)

{azureml_registry_tools-0.1.0a11 → azureml_registry_tools-0.1.0a13/azureml_registry_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: azureml-registry-tools
-Version: 0.1.0a11
+Version: 0.1.0a13
 Summary: AzureML Registry tools and CLI
 Author: Microsoft Corp
 License: https://aka.ms/azureml-sdk-license

{azureml_registry_tools-0.1.0a11 → azureml_registry_tools-0.1.0a13}/azureml_registry_tools.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ azureml/registry/_rest_client/__init__.py
 azureml/registry/_rest_client/arm_client.py
 azureml/registry/_rest_client/base_rest_client.py
 azureml/registry/_rest_client/registry_management_client.py
+azureml/registry/_rest_client/registry_model_client.py
 azureml/registry/data/__init__.py
 azureml/registry/data/asset.yaml.template
 azureml/registry/data/description.md.template
@@ -26,6 +27,7 @@ azureml/registry/mgmt/asset_management.py
 azureml/registry/mgmt/create_asset_template.py
 azureml/registry/mgmt/create_manifest.py
 azureml/registry/mgmt/create_model_spec.py
+azureml/registry/mgmt/model_management.py
 azureml/registry/mgmt/registry_config.py
 azureml/registry/mgmt/syndication_manifest.py
 azureml/registry/tools/__init__.py

{azureml_registry_tools-0.1.0a11 → azureml_registry_tools-0.1.0a13}/setup.py

@@ -18,7 +18,7 @@ exclude_list = ["*.tests"]
 
 setup(
     name='azureml-registry-tools',
-    version="0.1.0a11",
+    version="0.1.0a13",
     description='AzureML Registry tools and CLI',
     author='Microsoft Corp',
     license="https://aka.ms/azureml-sdk-license",