Use cached properties, match, string methods

Author: alganet

apywire/runtime.py

@@ -10,6 +10,7 @@
 import asyncio
 import importlib
 import re
+from functools import cached_property
 from operator import itemgetter
 from typing import Awaitable, Callable, Protocol, cast, final
 
@@ -108,17 +109,15 @@ def __getattr__(self, name: str) -> Accessor:
             f"'{type(self).__name__}' object has no attribute '{name}'"
         )
 
-    @property
+    @cached_property
     def aio(self) -> "AioAccessor":
         """Return a wrapper object providing async accessors.
 
         Use `await wired.aio.name()` to obtain the instantiated value
         asynchronously. We use `aio` to avoid the reserved keyword
         `async` (so `wired.async` would be invalid syntax).
         """
-        if not hasattr(self, "_aio_accessor"):
-            self._aio_accessor = AioAccessor(self)
-        return self._aio_accessor
+        return AioAccessor(self)
 
     def _instantiate_attr(
         self,
@@ -274,12 +273,15 @@ def _resolve_runtime(
             # Call the accessor `self.name()` to get the runtime value.
             return cast(object, getattr(self, o.name)())
 
-        elif isinstance(o, dict):
-            return {k: self._resolve_runtime(v, context) for k, v in o.items()}
-        elif isinstance(o, list):
-            return [self._resolve_runtime(v, context) for v in o]
-        elif isinstance(o, tuple):
-            return tuple(self._resolve_runtime(v, context) for v in o)
+        match o:
+            case dict():
+                return {
+                    k: self._resolve_runtime(v, context) for k, v in o.items()
+                }
+            case list():
+                return [self._resolve_runtime(v, context) for v in o]
+            case tuple():
+                return tuple(self._resolve_runtime(v, context) for v in o)
         return o
 
     def _format_string_constant(

apywire/wiring.py

@@ -289,26 +289,28 @@ def _extract_placeholder_name(self, s: str) -> str:
         Returns:
             The placeholder name without braces
         """
-        return s[len(PLACEHOLDER_START) : -len(PLACEHOLDER_END)]
+        return s.removeprefix(PLACEHOLDER_START).removesuffix(PLACEHOLDER_END)
 
     def _resolve(self, obj: _SpecValue) -> _ResolvedValue:
         """Resolve placeholders into `_WiredRef` markers for runtime.
 
         Replaces strings of the form "{name}" with a `_WiredRef(name)`
         for later resolution.
         """
-        if isinstance(obj, str):
-            if self._is_placeholder(obj):
-                ref_name = self._extract_placeholder_name(obj)
-                return _WiredRef(ref_name)
-            return obj
-        elif isinstance(obj, dict):
-            return {k: self._resolve(v) for k, v in obj.items()}
-        elif isinstance(obj, list):
-            return [self._resolve(v) for v in obj]
-        elif isinstance(obj, tuple):
-            return tuple(self._resolve(v) for v in obj)
-        return obj
+        match obj:
+            case str():
+                if self._is_placeholder(obj):
+                    ref_name = self._extract_placeholder_name(obj)
+                    return _WiredRef(ref_name)
+                return obj
+            case dict():
+                return {k: self._resolve(v) for k, v in obj.items()}
+            case list():
+                return [self._resolve(v) for v in obj]
+            case tuple():
+                return tuple(self._resolve(v) for v in obj)
+            case _:
+                return obj
 
     def _interpolate_placeholders(
         self,
@@ -354,16 +356,17 @@ def _find_placeholder_names(self, obj: _SpecValue) -> set[str]:
             Set of placeholder names found
         """
         names: set[str] = set()
-        if isinstance(obj, str):
-            # Find all placeholders in the string (embedded or not)
-            matches: list[str] = re.findall(self._placeholder_pattern, obj)
-            names.update(matches)
-        elif isinstance(obj, dict):
-            for v in obj.values():
-                names.update(self._find_placeholder_names(v))
-        elif isinstance(obj, (list, tuple)):
-            for v in obj:
-                names.update(self._find_placeholder_names(v))
+        match obj:
+            case str():
+                # Find all placeholders in the string (embedded or not)
+                matches: list[str] = re.findall(self._placeholder_pattern, obj)
+                names.update(matches)
+            case dict():
+                for v in obj.values():
+                    names.update(self._find_placeholder_names(v))
+            case list() | tuple():
+                for v in obj:
+                    names.update(self._find_placeholder_names(v))
         return names
 
     def _topological_sort(
@@ -454,13 +457,16 @@ def _resolve_constant(
 
             # Handle embedded placeholders via string interpolation
             return self._interpolate_placeholders(value, resolved, "constant")
-        elif isinstance(value, dict):
-            return {
-                k: self._resolve_constant(v, resolved)
-                for k, v in value.items()
-            }
-        elif isinstance(value, list):
-            return [self._resolve_constant(v, resolved) for v in value]
-        elif isinstance(value, tuple):
-            return tuple(self._resolve_constant(v, resolved) for v in value)
+        match value:
+            case dict():
+                return {
+                    k: self._resolve_constant(v, resolved)
+                    for k, v in value.items()
+                }
+            case list():
+                return [self._resolve_constant(v, resolved) for v in value]
+            case tuple():
+                return tuple(
+                    self._resolve_constant(v, resolved) for v in value
+                )
         return value

tests/test_edge_cases.py

@@ -195,15 +195,13 @@ def failing_maker() -> None:
 
 
 def test_wiring_aio_lazy_init() -> None:
-    """Test lazy initialization of aio property."""
+    """Test initialization of aio accessor with @cached_property."""
     from apywire import Wiring
 
     wired = Wiring({}, thread_safe=False)
-    # Access internal attribute to verify it's not there yet
-    assert not hasattr(wired, "_aio_accessor")
-    # Access property
+    # Access property (cached_property handles caching automatically)
     aio = wired.aio
-    assert hasattr(wired, "_aio_accessor")
+    # Verify same object is returned (caching works)
     assert wired.aio is aio