registry-device

Author: HangyiWang

azext_iot/adr/_help.py

@@ -398,60 +398,60 @@ def load_adr_help():
   """
 
     helps[
-        "iot adr ns adaptive-device"
+        "iot adr ns registry-device"
     ] = """
     type: group
-    short-summary: Manage Device Registry namespace adaptive devices.
+    short-summary: Manage Device Registry namespace registry devices.
   """
 
     helps[
-        "iot adr ns adaptive-device create"
+        "iot adr ns registry-device create"
     ] = """
   type: command
-  short-summary: Create an adaptive device in a Device Registry namespace.
+  short-summary: Create a registry device in a Device Registry namespace.
   examples:
-    - name: Create an adaptive device with descriptive metadata
-      text: az iot adr ns adaptive-device create -n myDevice --ns myNamespace -g myResourceGroup --manufacturer Contoso --model X1 --external-device-id ext-123
+    - name: Create a registry device with descriptive metadata
+      text: az iot adr ns registry-device create -n myDevice --ns myNamespace -g myResourceGroup --manufacturer Contoso --model X1 --external-device-id ext-123
   """
 
     helps[
-        "iot adr ns adaptive-device show"
+        "iot adr ns registry-device show"
     ] = """
   type: command
-  short-summary: Show the details of an adaptive device.
+  short-summary: Show the details of a registry device.
   examples:
-    - name: Show an adaptive device
-      text: az iot adr ns adaptive-device show -n myDevice --ns myNamespace -g myResourceGroup
+    - name: Show a registry device
+      text: az iot adr ns registry-device show -n myDevice --ns myNamespace -g myResourceGroup
   """
 
     helps[
-        "iot adr ns adaptive-device list"
+        "iot adr ns registry-device list"
     ] = """
   type: command
-  short-summary: List the adaptive devices in a Device Registry namespace.
+  short-summary: List the registry devices in a Device Registry namespace.
   examples:
-    - name: List adaptive devices
-      text: az iot adr ns adaptive-device list --ns myNamespace -g myResourceGroup
+    - name: List registry devices
+      text: az iot adr ns registry-device list --ns myNamespace -g myResourceGroup
   """
 
     helps[
-        "iot adr ns adaptive-device update"
+        "iot adr ns registry-device update"
     ] = """
   type: command
-  short-summary: Update an adaptive device.
+  short-summary: Update a registry device.
   examples:
-    - name: Update an adaptive device's software revision
-      text: az iot adr ns adaptive-device update -n myDevice --ns myNamespace -g myResourceGroup --software-revision 2.0
+    - name: Update a registry device's software revision
+      text: az iot adr ns registry-device update -n myDevice --ns myNamespace -g myResourceGroup --software-revision 2.0
   """
 
     helps[
-        "iot adr ns adaptive-device delete"
+        "iot adr ns registry-device delete"
     ] = """
   type: command
-  short-summary: Delete an adaptive device from a Device Registry namespace.
+  short-summary: Delete a registry device from a Device Registry namespace.
   examples:
-    - name: Delete an adaptive device
-      text: az iot adr ns adaptive-device delete -n myDevice --ns myNamespace -g myResourceGroup
+    - name: Delete a registry device
+      text: az iot adr ns registry-device delete -n myDevice --ns myNamespace -g myResourceGroup
   """
 
     helps[

azext_iot/adr/command_map.py

@@ -33,8 +33,8 @@
     client_factory=adr_service_factory,
 )
 
-adr_adaptive_device_ops = CliCommandType(
-    operations_tmpl="azext_iot.adr.commands_adaptive_device#{}",
+adr_registry_device_ops = CliCommandType(
+    operations_tmpl="azext_iot.adr.commands_registry_device#{}",
     client_factory=adr_service_factory,
 )
 
@@ -120,15 +120,15 @@ def load_adr_commands(self, _):
         cmd_group.command("update", "adr_ca_policy_update", supports_no_wait=True)
         cmd_group.command("delete", "adr_ca_policy_delete", confirmation=True, supports_no_wait=True)
 
-    # Adaptive Device commands
+    # Registry Device commands
     with self.command_group(
-        "iot adr ns adaptive-device", command_type=adr_adaptive_device_ops
+        "iot adr ns registry-device", command_type=adr_registry_device_ops
     ) as cmd_group:
-        cmd_group.command("create", "adr_adaptive_device_create")
-        cmd_group.show_command("show", "adr_adaptive_device_show")
-        cmd_group.command("list", "adr_adaptive_device_list")
-        cmd_group.command("update", "adr_adaptive_device_update")
-        cmd_group.command("delete", "adr_adaptive_device_delete", confirmation=True, supports_no_wait=True)
+        cmd_group.command("create", "adr_registry_device_create")
+        cmd_group.show_command("show", "adr_registry_device_show")
+        cmd_group.command("list", "adr_registry_device_list")
+        cmd_group.command("update", "adr_registry_device_update")
+        cmd_group.command("delete", "adr_registry_device_delete", confirmation=True, supports_no_wait=True)
 
     # Device commands
     with self.command_group("iot adr ns device", command_type=adr_device_ops) as cmd_group:

azext_iot/adr/commands_adaptive_device.py azext_iot/adr/commands_registry_device.pyazext_iot/adr/commands_adaptive_device.py renamed to azext_iot/adr/commands_registry_device.py

@@ -8,14 +8,14 @@
 
 from knack.log import get_logger
 
-from azext_iot.adr.providers.adaptive_device import AdaptiveDeviceProvider
+from azext_iot.adr.providers.registry_device import RegistryDeviceProvider
 
 logger = get_logger(__name__)
 
 
-def adr_adaptive_device_create(
+def adr_registry_device_create(
     cmd,
-    adaptive_device_name: str,
+    registry_device_name: str,
     namespace_name: str,
     resource_group_name: str,
     external_device_id: Optional[str] = None,
@@ -27,9 +27,9 @@ def adr_adaptive_device_create(
     tags: Optional[Dict[str, str]] = None,
     **kwargs,
 ):
-    provider = AdaptiveDeviceProvider(cmd)
+    provider = RegistryDeviceProvider(cmd)
     return provider.create(
-        adaptive_device_name=adaptive_device_name,
+        registry_device_name=registry_device_name,
         namespace_name=namespace_name,
         resource_group_name=resource_group_name,
         external_device_id=external_device_id,
@@ -43,28 +43,28 @@ def adr_adaptive_device_create(
     )
 
 
-def adr_adaptive_device_show(
-    cmd, adaptive_device_name: str, namespace_name: str, resource_group_name: str
+def adr_registry_device_show(
+    cmd, registry_device_name: str, namespace_name: str, resource_group_name: str
 ):
-    provider = AdaptiveDeviceProvider(cmd)
+    provider = RegistryDeviceProvider(cmd)
     return provider.show(
-        adaptive_device_name=adaptive_device_name,
+        registry_device_name=registry_device_name,
         namespace_name=namespace_name,
         resource_group_name=resource_group_name,
     )
 
 
-def adr_adaptive_device_list(cmd, namespace_name: str, resource_group_name: str):
-    provider = AdaptiveDeviceProvider(cmd)
+def adr_registry_device_list(cmd, namespace_name: str, resource_group_name: str):
+    provider = RegistryDeviceProvider(cmd)
     return provider.list(
         namespace_name=namespace_name,
         resource_group_name=resource_group_name,
     )
 
 
-def adr_adaptive_device_update(
+def adr_registry_device_update(
     cmd,
-    adaptive_device_name: str,
+    registry_device_name: str,
     namespace_name: str,
     resource_group_name: str,
     external_device_id: Optional[str] = None,
@@ -75,9 +75,9 @@ def adr_adaptive_device_update(
     tags: Optional[Dict[str, str]] = None,
     **kwargs,
 ):
-    provider = AdaptiveDeviceProvider(cmd)
+    provider = RegistryDeviceProvider(cmd)
     return provider.update(
-        adaptive_device_name=adaptive_device_name,
+        registry_device_name=registry_device_name,
         namespace_name=namespace_name,
         resource_group_name=resource_group_name,
         external_device_id=external_device_id,
@@ -90,12 +90,12 @@ def adr_adaptive_device_update(
     )
 
 
-def adr_adaptive_device_delete(
-    cmd, adaptive_device_name: str, namespace_name: str, resource_group_name: str, **kwargs
+def adr_registry_device_delete(
+    cmd, registry_device_name: str, namespace_name: str, resource_group_name: str, **kwargs
 ):
-    provider = AdaptiveDeviceProvider(cmd)
+    provider = RegistryDeviceProvider(cmd)
     return provider.delete(
-        adaptive_device_name=adaptive_device_name,
+        registry_device_name=registry_device_name,
         namespace_name=namespace_name,
         resource_group_name=resource_group_name,
         **kwargs,

azext_iot/adr/params.py

@@ -207,21 +207,21 @@ def load_adr_arguments(self, _):
             validator=get_default_location_from_resource_group,
         )
 
-    # Adaptive Device arguments
-    with self.argument_context("iot adr ns adaptive-device") as context:
+    # Registry Device arguments
+    with self.argument_context("iot adr ns registry-device") as context:
         context.argument(
             "namespace_name",
             options_list=["--namespace", "--ns"],
             help="Name of the Device Registry namespace.",
         )
         context.argument(
-            "adaptive_device_name",
+            "registry_device_name",
             options_list=["--name", "-n"],
-            help="Name of the adaptive device.",
+            help="Name of the registry device.",
         )
         context.argument("tags", arg_type=tags_type)
 
-    for cmd in ["iot adr ns adaptive-device create", "iot adr ns adaptive-device update"]:
+    for cmd in ["iot adr ns registry-device create", "iot adr ns registry-device update"]:
         with self.argument_context(cmd) as context:
             context.argument(
                 "external_device_id",
@@ -249,7 +249,7 @@ def load_adr_arguments(self, _):
                 help="Device software revision.",
             )
 
-    with self.argument_context("iot adr ns adaptive-device create") as context:
+    with self.argument_context("iot adr ns registry-device create") as context:
         context.argument(
             "location",
             arg_type=get_location_type(self.cli_ctx),

azext_iot/adr/providers/base.py

@@ -64,7 +64,7 @@ def _resolve_location(
     ):
         """Resolve a child resource location from its parent Device Registry namespace.
 
-        Child resources (certificate authorities, certificate policies, adaptive devices) must be
+        Child resources (certificate authorities, certificate policies, registry devices) must be
         co-located with their parent namespace, so default to the namespace's location when the
         caller does not specify one explicitly. Use this when a parent namespace is guaranteed to
         exist; use ``_ensure_location`` instead when only the resource group is available.

…ext_iot/adr/providers/adaptive_device.py …ext_iot/adr/providers/registry_device.pyazext_iot/adr/providers/adaptive_device.py renamed to azext_iot/adr/providers/registry_device.py azext_iot/adr/providers/adaptive_device.py renamed to azext_iot/adr/providers/registry_device.py

@@ -11,9 +11,9 @@
 from azext_iot.adr.providers.base import ADRProvider, console
 
 
-class AdaptiveDeviceProvider(ADRProvider):
+class RegistryDeviceProvider(ADRProvider):
     def __init__(self, cmd):
-        super(AdaptiveDeviceProvider, self).__init__(cmd)
+        super(RegistryDeviceProvider, self).__init__(cmd)
 
     @staticmethod
     def _build_properties(
@@ -38,7 +38,7 @@ def _build_properties(
 
     def create(
         self,
-        adaptive_device_name: str,
+        registry_device_name: str,
         namespace_name: str,
         resource_group_name: str,
         external_device_id: Optional[str] = None,
@@ -66,33 +66,33 @@ def create(
             resource["tags"] = tags
 
         with console.status(
-            f"Creating adaptive device '{adaptive_device_name}' on namespace {namespace_name}..."
+            f"Creating registry device '{registry_device_name}' on namespace {namespace_name}..."
         ):
-            return self.client.namespace_adaptive_devices.create_or_replace(
+            return self.client.registry_devices.create_or_replace(
                 resource_group_name=resource_group_name,
                 namespace_name=namespace_name,
-                adaptive_device_name=adaptive_device_name,
+                registry_device_name=registry_device_name,
                 resource=resource,
             )
 
-    def show(self, adaptive_device_name: str, namespace_name: str, resource_group_name: str):
-        return self.client.namespace_adaptive_devices.get(
+    def show(self, registry_device_name: str, namespace_name: str, resource_group_name: str):
+        return self.client.registry_devices.get(
             resource_group_name=resource_group_name,
             namespace_name=namespace_name,
-            adaptive_device_name=adaptive_device_name,
+            registry_device_name=registry_device_name,
         )
 
     def list(self, namespace_name: str, resource_group_name: str):
         return list(
-            self.client.namespace_adaptive_devices.list_by_namespace(
+            self.client.registry_devices.list_by_namespace(
                 resource_group_name=resource_group_name,
                 namespace_name=namespace_name,
             )
         )
 
     def update(
         self,
-        adaptive_device_name: str,
+        registry_device_name: str,
         namespace_name: str,
         resource_group_name: str,
         external_device_id: Optional[str] = None,
@@ -121,23 +121,23 @@ def update(
             body["tags"] = tags
 
         with console.status(
-            f"Updating adaptive device '{adaptive_device_name}' on namespace {namespace_name}..."
+            f"Updating registry device '{registry_device_name}' on namespace {namespace_name}..."
         ):
-            return self.client.namespace_adaptive_devices.update(
+            return self.client.registry_devices.update(
                 resource_group_name=resource_group_name,
                 namespace_name=namespace_name,
-                adaptive_device_name=adaptive_device_name,
+                registry_device_name=registry_device_name,
                 properties=body,
             )
 
-    def delete(self, adaptive_device_name: str, namespace_name: str, resource_group_name: str, **kwargs):
-        poller = self.client.namespace_adaptive_devices.begin_delete(
+    def delete(self, registry_device_name: str, namespace_name: str, resource_group_name: str, **kwargs):
+        poller = self.client.registry_devices.begin_delete(
             resource_group_name=resource_group_name,
             namespace_name=namespace_name,
-            adaptive_device_name=adaptive_device_name,
+            registry_device_name=registry_device_name,
         )
         return self._wait(
             poller,
-            f"Deleting adaptive device '{adaptive_device_name}' from namespace {namespace_name}...",
+            f"Deleting registry device '{registry_device_name}' from namespace {namespace_name}...",
             **kwargs,
         )

azext_iot/sdk/deviceregistry/_client.py

@@ -25,6 +25,7 @@
     NamespaceDevicesOperations,
     NamespacesOperations,
     PoliciesOperations,
+    RegistryDevicesOperations,
 )
 
 if TYPE_CHECKING:
@@ -51,6 +52,8 @@ class MicrosoftDeviceRegistryManagementService:  # pylint: disable=too-many-inst
     :vartype policies: azext_iot.sdk.deviceregistry.operations.PoliciesOperations
     :ivar namespace_devices: NamespaceDevicesOperations operations
     :vartype namespace_devices: azext_iot.sdk.deviceregistry.operations.NamespaceDevicesOperations
+    :ivar registry_devices: RegistryDevicesOperations operations
+    :vartype registry_devices: azext_iot.sdk.deviceregistry.operations.RegistryDevicesOperations
     :param credential: Credential needed for the client to connect to Azure. Required.
     :type credential: ~azure.core.credentials.TokenCredential
     :param subscription_id: The ID of the target subscription. The value must be an UUID. Required.
@@ -112,6 +115,9 @@ def __init__(
         self.namespace_devices = NamespaceDevicesOperations(
             self._client, self._config, self._serialize, self._deserialize
         )
+        self.registry_devices = RegistryDevicesOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
 
     def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse:
         """Runs the network request through the client's chained policies.