Refactor: Use new registration method

tykeal · tykeal · commit 0309971352cb · 2025-10-16T14:03:46.000-07:00
* Move service registration to __init__.py and convert lock services to
  instance methods.
* Update services.yaml and strings.json to use target instead of
  entity_id.

Signed-off-by: Andrew Grimberg &lt;tykeal@bardicgrove.org&gt;
diff --git a/homeassistant/components/schlage/__init__.py b/homeassistant/components/schlage/__init__.py
@@ -4,11 +4,15 @@
 
 from pycognito.exceptions import WarrantException
 import pyschlage
+import voluptuous as vol
 
+from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, SupportsResponse
 from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers import config_validation as cv, service
 
+from .const import DOMAIN, SERVICE_ADD_CODE, SERVICE_DELETE_CODE, SERVICE_GET_CODES
 from .coordinator import SchlageConfigEntry, SchlageDataUpdateCoordinator
 
 PLATFORMS: list[Platform] = [
@@ -36,6 +40,40 @@ async def async_setup_entry(hass: HomeAssistant, entry: SchlageConfigEntry) -> b
 
     await coordinator.async_config_entry_first_refresh()
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_ADD_CODE,
+        entity_domain=LOCK_DOMAIN,
+        schema={
+            vol.Required("name"): cv.string,
+            vol.Required("code"): cv.matches_regex(r"^\d{4,8}$"),
+        },
+        func=SERVICE_ADD_CODE,
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_DELETE_CODE,
+        entity_domain=LOCK_DOMAIN,
+        schema={
+            vol.Required("name"): cv.string,
+        },
+        func=SERVICE_DELETE_CODE,
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_GET_CODES,
+        entity_domain=LOCK_DOMAIN,
+        schema=None,
+        func=SERVICE_GET_CODES,
+        supports_response=SupportsResponse.ONLY,
+    )
+
     return True
 
 
diff --git a/homeassistant/components/schlage/lock.py b/homeassistant/components/schlage/lock.py
@@ -5,21 +5,13 @@
 from typing import Any
 
 from pyschlage.code import AccessCode
-import voluptuous as vol
 
 from homeassistant.components.lock import LockEntity
-from homeassistant.core import (
-    HomeAssistant,
-    ServiceCall,
-    ServiceResponse,
-    SupportsResponse,
-    callback,
-)
+from homeassistant.core import HomeAssistant, ServiceResponse, callback
 from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN, SERVICE_ADD_CODE, SERVICE_DELETE_CODE, SERVICE_GET_CODES
+from .const import DOMAIN
 from .coordinator import LockData, SchlageConfigEntry, SchlageDataUpdateCoordinator
 from .entity import SchlageEntity
 
@@ -41,16 +33,56 @@ def _add_new_locks(locks: dict[str, LockData]) -> None:
     _add_new_locks(coordinator.data.locks)
     coordinator.new_locks_callbacks.append(_add_new_locks)
 
-    # Custom services
-    def _validate_code_name(codes: dict[str, AccessCode] | None, name: str) -> None:
+
+class SchlageLockEntity(SchlageEntity, LockEntity):
+    """Schlage lock entity."""
+
+    _attr_name = None
+
+    def __init__(
+        self, coordinator: SchlageDataUpdateCoordinator, device_id: str
+    ) -> None:
+        """Initialize a Schlage Lock."""
+        super().__init__(coordinator=coordinator, device_id=device_id)
+        self._update_attrs()
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        if self.device_id in self.coordinator.data.locks:
+            self._update_attrs()
+        super()._handle_coordinator_update()
+
+    def _update_attrs(self) -> None:
+        """Update our internal state attributes."""
+        self._attr_is_locked = self._lock.is_locked
+        self._attr_is_jammed = self._lock.is_jammed
+        self._attr_changed_by = self._lock.last_changed_by()
+
+    async def async_lock(self, **kwargs: Any) -> None:
+        """Lock the device."""
+        await self.hass.async_add_executor_job(self._lock.lock)
+        await self.coordinator.async_request_refresh()
+
+    async def async_unlock(self, **kwargs: Any) -> None:
+        """Unlock the device."""
+        await self.hass.async_add_executor_job(self._lock.unlock)
+        await self.coordinator.async_request_refresh()
+
+    # Door code services
+    def _validate_code_name(
+        self, codes: dict[str, AccessCode] | None, name: str
+    ) -> None:
         """Validate that the code name doesn't already exist."""
         if codes and any(code.name.lower() == name.lower() for code in codes.values()):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
                 translation_key="schlage_name_exists",
             )
 
-    def _validate_code_value(codes: dict[str, AccessCode] | None, code: str) -> None:
+    def _validate_code_value(
+        self, codes: dict[str, AccessCode] | None, code: str
+    ) -> None:
         """Validate that the code value doesn't already exist."""
         if codes and any(
             existing_code.code == code for existing_code in codes.values()
@@ -60,18 +92,8 @@ def _validate_code_value(codes: dict[str, AccessCode] | None, code: str) -> None
                 translation_key="schlage_code_exists",
             )
 
-    async def _add_code(entity: SchlageLockEntity, calls: ServiceCall) -> None:
+    async def add_code(self, name: str, code: str) -> None:
         """Add a lock code."""
-        name = calls.data.get("name")
-        code = calls.data.get("code")
-
-        # name is required by voluptuous, the following is just to satisfy type
-        # checker, it should never be None
-        if name is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="schlage_name_required",
-            )  # pragma: no cover
 
         # code is required by voluptuous, the following is just to satisfy type
         # checker, it should never be None
@@ -81,27 +103,19 @@ async def _add_code(entity: SchlageLockEntity, calls: ServiceCall) -> None:
                 translation_key="schlage_code_required",
             )  # pragma: no cover
 
-        codes = entity._lock.access_codes  # noqa: SLF001
-        _validate_code_name(codes, name)
-        _validate_code_value(codes, code)
+        codes = self._lock.access_codes
+        self._validate_code_name(codes, name)
+        self._validate_code_value(codes, code)
 
         access_code = AccessCode(name=name, code=code)
-        await hass.async_add_executor_job(entity._lock.add_access_code, access_code)  # noqa: SLF001
-        await coordinator.async_request_refresh()
+        await self.coordinator.hass.async_add_executor_job(
+            self._lock.add_access_code, access_code
+        )
+        await self.coordinator.async_request_refresh()
 
-    async def _delete_code(entity: SchlageLockEntity, calls: ServiceCall) -> None:
+    async def delete_code(self, name: str) -> None:
         """Delete a lock code."""
-        name = calls.data.get("name")
-
-        # name is required by voluptuous, the following is just to satisfy type
-        # checker, it should never be None
-        if name is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="schlage_name_required",
-            )  # pragma: no cover
-
-        codes = entity._lock.access_codes  # noqa: SLF001
+        codes = self._lock.access_codes
         if not codes:
             return
 
@@ -117,84 +131,21 @@ async def _delete_code(entity: SchlageLockEntity, calls: ServiceCall) -> None:
         if not code_id_to_delete:
             return
 
-        if entity._lock.access_codes:  # noqa: SLF001
-            await hass.async_add_executor_job(
-                entity._lock.access_codes[code_id_to_delete].delete  # noqa: SLF001
+        if self._lock.access_codes:
+            await self.coordinator.hass.async_add_executor_job(
+                self._lock.access_codes[code_id_to_delete].delete
             )
-            await coordinator.async_request_refresh()
+            await self.coordinator.async_request_refresh()
 
-    async def _get_codes(
-        entity: SchlageLockEntity, calls: ServiceCall
-    ) -> ServiceResponse:
+    async def get_codes(self) -> ServiceResponse:
         """Get lock codes."""
 
-        if entity._lock.access_codes:  # noqa: SLF001
+        if self._lock.access_codes:
             return {
                 code: {
-                    "name": entity._lock.access_codes[code].name,  # noqa: SLF001
-                    "code": entity._lock.access_codes[code].code,  # noqa: SLF001
+                    "name": self._lock.access_codes[code].name,
+                    "code": self._lock.access_codes[code].code,
                 }
-                for code in entity._lock.access_codes  # noqa: SLF001
+                for code in self._lock.access_codes
             }
         return {}
-
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        name=SERVICE_ADD_CODE,
-        schema={
-            vol.Required("name"): cv.string,
-            vol.Required("code"): cv.matches_regex(r"^\d{4,8}$"),
-        },
-        func=_add_code,
-    )
-
-    platform.async_register_entity_service(
-        name=SERVICE_DELETE_CODE,
-        schema={
-            vol.Required("name"): cv.string,
-        },
-        func=_delete_code,
-    )
-
-    platform.async_register_entity_service(
-        name=SERVICE_GET_CODES,
-        schema=None,
-        func=_get_codes,
-        supports_response=SupportsResponse.ONLY,
-    )
-
-
-class SchlageLockEntity(SchlageEntity, LockEntity):
-    """Schlage lock entity."""
-
-    _attr_name = None
-
-    def __init__(
-        self, coordinator: SchlageDataUpdateCoordinator, device_id: str
-    ) -> None:
-        """Initialize a Schlage Lock."""
-        super().__init__(coordinator=coordinator, device_id=device_id)
-        self._update_attrs()
-
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-        if self.device_id in self.coordinator.data.locks:
-            self._update_attrs()
-        super()._handle_coordinator_update()
-
-    def _update_attrs(self) -> None:
-        """Update our internal state attributes."""
-        self._attr_is_locked = self._lock.is_locked
-        self._attr_is_jammed = self._lock.is_jammed
-        self._attr_changed_by = self._lock.last_changed_by()
-
-    async def async_lock(self, **kwargs: Any) -> None:
-        """Lock the device."""
-        await self.hass.async_add_executor_job(self._lock.lock)
-        await self.coordinator.async_request_refresh()
-
-    async def async_unlock(self, **kwargs: Any) -> None:
-        """Unlock the device."""
-        await self.hass.async_add_executor_job(self._lock.unlock)
-        await self.coordinator.async_request_refresh()
diff --git a/homeassistant/components/schlage/services.yaml b/homeassistant/components/schlage/services.yaml
@@ -1,24 +1,15 @@
 get_codes:
-  fields:
-    entity_id:
-      required: true
-      selector:
-        entity:
-          filter:
-            domain: lock
-            integration: schlage
-          multiple: true
+  target:
+    entity:
+      domain: lock
+      integration: schlage
 
 add_code:
+  target:
+    entity:
+      domain: lock
+      integration: schlage
   fields:
-    entity_id:
-      required: true
-      selector:
-        entity:
-          filter:
-            domain: lock
-            integration: schlage
-          multiple: true
     name:
       required: true
       example: "Example Person"
@@ -33,15 +24,11 @@ add_code:
           multiline: false
 
 delete_code:
+  target:
+    entity:
+      domain: lock
+      integration: schlage
   fields:
-    entity_id:
-      required: true
-      selector:
-        entity:
-          filter:
-            domain: lock
-            integration: schlage
-          multiple: true
     name:
       required: true
       example: "Example Person"
diff --git a/homeassistant/components/schlage/strings.json b/homeassistant/components/schlage/strings.json
@@ -77,10 +77,6 @@
       "name": "Add PIN code",
       "description": "Add a PIN code to a lock.",
       "fields": {
-        "entity_id": {
-          "name": "Lock",
-          "description": "The lock to add the PIN code to."
-        },
         "name": {
           "name": "PIN Name",
           "description": "Name for PIN code. Must be unique to lock."
@@ -95,10 +91,6 @@
       "name": "Delete PIN code",
       "description": "Delete a PIN code from a lock.",
       "fields": {
-        "entity_id": {
-          "name": "Lock",
-          "description": "The lock to delete the PIN code from."
-        },
         "name": {
           "name": "PIN Name",
           "description": "Name of PIN code to delete."
@@ -107,13 +99,7 @@
     },
     "get_codes": {
       "name": "Get PIN codes",
-      "description": "Retrieve all PIN codes from the lock",
-      "fields": {
-        "entity_id": {
-          "name": "Lock",
-          "description": "The lock to retrieve PIN codes from."
-        }
-      }
+      "description": "Retrieve all PIN codes from the lock"
     }
   }
 }
