Housekeeping

 - Refactored the main module
 - Increased code coverage

Author: alganet

apywire/compiler.py

@@ -128,66 +128,8 @@ def _compile_property(
         # lambda passed to a thread pool executor is pure synchronous.
         pre_statements: list[ast.stmt] = []
 
-        # Helper to extract `await self.<name>()` occurrences from AST
-        # expressions and replace them with local variables. This lets us
-        # run a synchronous lambda in `run_in_executor` without `await`
-        # nodes embedded inside it.
-        counter = 0
-
-        def _replace_awaits_with_locals(node: ast.expr) -> ast.expr:
-            nonlocal counter
-
-            if isinstance(node, ast.Await):
-                inner = node.value
-                if (
-                    isinstance(inner, ast.Call)
-                    and isinstance(inner.func, ast.Attribute)
-                    and isinstance(inner.func.value, ast.Name)
-                    and inner.func.value.id == "self"
-                ):
-                    # produce a unique variable name and precompute the await
-                    counter += 1
-                    var_name = f"{COMPILED_VAR_PREFIX}{counter}"
-                    assign = ast.Assign(
-                        targets=[ast.Name(id=var_name, ctx=ast.Store())],
-                        value=node,
-                    )
-                    pre_statements.append(assign)
-                    return ast.Name(id=var_name, ctx=ast.Load())
-                return node
-
-            # Recurse into common composite nodes
-            if isinstance(node, ast.Call):
-                new_args = [_replace_awaits_with_locals(a) for a in node.args]
-                new_keywords = [
-                    ast.keyword(
-                        arg=k.arg, value=_replace_awaits_with_locals(k.value)
-                    )
-                    for k in node.keywords
-                ]
-                return ast.Call(
-                    func=node.func, args=new_args, keywords=new_keywords
-                )
-            if isinstance(node, ast.Dict):
-                new_keys = [
-                    _replace_awaits_with_locals(k) if k is not None else None
-                    for k in node.keys
-                ]
-                new_values = [
-                    _replace_awaits_with_locals(v) for v in node.values
-                ]
-                return ast.Dict(keys=new_keys, values=new_values)
-            if isinstance(node, ast.List):
-                return ast.List(
-                    elts=[_replace_awaits_with_locals(e) for e in node.elts],
-                    ctx=node.ctx,
-                )
-            if isinstance(node, ast.Tuple):
-                return ast.Tuple(
-                    elts=[_replace_awaits_with_locals(e) for e in node.elts],
-                    ctx=node.ctx,
-                )
-            return node
+        # Counter for generating unique variable names (mutable list)
+        counter = [0]
 
         args: list[ast.expr] = []
 
@@ -210,7 +152,9 @@ def _replace_awaits_with_locals(node: ast.expr) -> ast.expr:
         for i, value in enumerate(args_data):
             raw_val_ast = self._astify(value, aio=aio)
             if aio:
-                val_ast = _replace_awaits_with_locals(raw_val_ast)
+                val_ast = self._replace_awaits_with_locals(
+                    raw_val_ast, pre_statements, counter
+                )
                 var_name = f"{COMPILED_ARG_PREFIX}{i}"
                 assign = ast.Assign(
                     targets=[ast.Name(id=var_name, ctx=ast.Store())],
@@ -229,7 +173,9 @@ def _replace_awaits_with_locals(node: ast.expr) -> ast.expr:
                 # Replace any awaited accessors with local precomputed
                 # variables and assign all values to local variables so
                 # that the executor lambda can be synchronous.
-                val_ast = _replace_awaits_with_locals(raw_val_ast)
+                val_ast = self._replace_awaits_with_locals(
+                    raw_val_ast, pre_statements, counter
+                )
                 # Use named variables for top-level keyword args to make
                 # the generated code more readable and deterministic.
                 var_name = f"{COMPILED_VAR_PREFIX}{key}"
@@ -494,6 +440,101 @@ def _replace_awaits_with_locals(node: ast.expr) -> ast.expr:
             )
         return func_def
 
+    def _replace_awaits_with_locals(
+        self,
+        node: ast.expr,
+        pre_statements: list[ast.stmt],
+        counter: list[int],
+    ) -> ast.expr:
+        """Replace await expressions with local variable assignments.
+
+        Recursively processes AST nodes to replace `ast.Await` expressions
+        with local variable assignments. This ensures that synchronous lambdas
+        executed in a thread pool do not contain `await` nodes.
+
+        Args:
+            node: AST expression node to process
+            pre_statements: List to accumulate pre-computation statements
+            counter: Single-element list used as mutable counter for var naming
+
+        Returns:
+            Transformed AST expression node
+        """
+        if isinstance(node, ast.Await):
+            inner = node.value
+            if (
+                isinstance(inner, ast.Call)
+                and isinstance(inner.func, ast.Attribute)
+                and isinstance(inner.func.value, ast.Name)
+                and inner.func.value.id == "self"
+            ):
+                # produce a unique variable name and precompute the await
+                counter[0] += 1
+                var_name = f"{COMPILED_VAR_PREFIX}{counter[0]}"
+                assign = ast.Assign(
+                    targets=[ast.Name(id=var_name, ctx=ast.Store())],
+                    value=node,
+                )
+                pre_statements.append(assign)
+                return ast.Name(id=var_name, ctx=ast.Load())
+            return node
+
+        # Recurse into common composite nodes
+        if isinstance(node, ast.Call):
+            new_args = [
+                self._replace_awaits_with_locals(a, pre_statements, counter)
+                for a in node.args
+            ]
+            new_keywords = [
+                ast.keyword(
+                    arg=k.arg,
+                    value=self._replace_awaits_with_locals(
+                        k.value, pre_statements, counter
+                    ),
+                )
+                for k in node.keywords
+            ]
+            return ast.Call(
+                func=node.func, args=new_args, keywords=new_keywords
+            )
+        if isinstance(node, ast.Dict):
+            new_keys = [
+                (
+                    self._replace_awaits_with_locals(
+                        k, pre_statements, counter
+                    )
+                    if k is not None
+                    else None
+                )
+                for k in node.keys
+            ]
+            new_values = [
+                self._replace_awaits_with_locals(v, pre_statements, counter)
+                for v in node.values
+            ]
+            return ast.Dict(keys=new_keys, values=new_values)
+        if isinstance(node, ast.List):
+            return ast.List(
+                elts=[
+                    self._replace_awaits_with_locals(
+                        e, pre_statements, counter
+                    )
+                    for e in node.elts
+                ],
+                ctx=node.ctx,
+            )
+        if isinstance(node, ast.Tuple):
+            return ast.Tuple(
+                elts=[
+                    self._replace_awaits_with_locals(
+                        e, pre_statements, counter
+                    )
+                    for e in node.elts
+                ],
+                ctx=node.ctx,
+            )
+        return node
+
     def _compile_constant_property(
         self,
         name: str,

apywire/threads.py

@@ -88,7 +88,38 @@ def _release_held_locks(self) -> None:
             return
         for lock in reversed(self._local.held_locks):
             lock.release()
-        self._local.held_locks = []
+        self._local.held_locks.clear()
+
+    def _check_cache(self, name: str) -> tuple[bool, object | None]:
+        """Check if attribute is cached, return (found, value) tuple.
+
+        Checks both _values dict (if present) and _<name> attribute.
+        Returns (True, value) if cached, (False, None) if not found.
+        """
+        cache_attr = f"{CACHE_ATTR_PREFIX}{name}"
+
+        # Check _values dict first (runtime path)
+        if hasattr(self, "_values"):
+            values_dict = cast(dict[str, object], getattr(self, "_values"))
+            if name in values_dict:
+                return (True, values_dict[name])
+
+        # Check cached attribute (compiled path)
+        if hasattr(self, cache_attr):
+            return (True, cast(object, getattr(self, cache_attr)))
+
+        return (False, None)
+
+    def _set_cache(self, name: str, value: object) -> None:
+        """Store value in cache using appropriate storage mechanism.
+
+        Uses _values dict if present, otherwise uses _<name> attribute.
+        """
+        if hasattr(self, "_values"):
+            self._values[name] = value
+        else:
+            cache_attr = f"{CACHE_ATTR_PREFIX}{name}"
+            setattr(self, cache_attr, value)
 
     def _wrap_instantiation_error(self, e: Exception, name: str) -> NoReturn:
         """Wrap exceptions during instantiation with proper context.
@@ -119,12 +150,10 @@ def _instantiate_attr(
         thread-safe locking logic permits it to run. Returns the cached
         attribute (``self._<name>``) if already present.
         """
-        cache_attr = f"{CACHE_ATTR_PREFIX}{name}"
-        # check cache mapping or attribute
-        if hasattr(self, "_values") and name in self._values:
-            return self._values[name]
-        if hasattr(self, cache_attr):
-            return cast(object, getattr(self, cache_attr))
+        # Check cache first
+        found, value = self._check_cache(name)
+        if found:
+            return value
 
         lock = self._get_attribute_lock(name)
         mode: str | None = getattr(self._local, "mode", None)
@@ -134,8 +163,9 @@ def _instantiate_attr(
             # If not, fall back to global lock.
             if lock.acquire(blocking=False):
                 try:
-                    if hasattr(self, cache_attr):
-                        return cast(object, getattr(self, cache_attr))
+                    found, value = self._check_cache(name)
+                    if found:
+                        return value
                     # Enter optimistic mode and track held locks to allow
                     # nested instantiation to detect per-attribute
                     # conflicts.
@@ -155,11 +185,8 @@ def _instantiate_attr(
                         lock.release()
                         self._wrap_instantiation_error(e, name)
                     else:
-                        # store both in mapping and attribute when available
-                        if hasattr(self, "_values"):
-                            self._values[name] = inst
-                        else:
-                            setattr(self, cache_attr, inst)
+                        # Store in cache
+                        self._set_cache(name, inst)
                         # Release the optimistic held locks before returning
                         self._release_held_locks()
                         return inst
@@ -185,13 +212,11 @@ def _instantiate_attr(
                     attempts = 0
                     while True:
                         try:
-                            if hasattr(self, cache_attr):
-                                return cast(object, getattr(self, cache_attr))
+                            found, value = self._check_cache(name)
+                            if found:
+                                return value
                             inst = maker()
-                            if hasattr(self, "_values"):
-                                self._values[name] = inst
-                            else:
-                                setattr(self, cache_attr, inst)
+                            self._set_cache(name, inst)
                             return inst
                         except LockUnavailableError:
                             attempts += 1
@@ -219,13 +244,11 @@ def _instantiate_attr(
             held = self._get_held_locks()
             held.append(lock)
             try:
-                if hasattr(self, cache_attr):
-                    return cast(object, getattr(self, cache_attr))
+                found, value = self._check_cache(name)
+                if found:
+                    return value
                 inst = maker()
-                if hasattr(self, "_values"):
-                    self._values[name] = inst
-                else:
-                    setattr(self, cache_attr, inst)
+                self._set_cache(name, inst)
                 return inst
             finally:
                 # Locks are intentionally not released here; they will be

tests/test_compile_aio.py

@@ -284,3 +284,83 @@ async def run() -> None:
         assert val == complex(1.0, 2.0)
 
     asyncio.run(run())
+
+
+def test_aio_compile_await_non_self_call() -> None:
+    """Test _replace_awaits_with_locals with non-self await nodes."""
+    from apywire import Spec, WiringCompiler
+
+    # Create spec with async compilation that could have nested awaits
+    spec: Spec = {
+        "datetime.datetime now": {"year": 2025, "month": 1, "day": 1},
+        "datetime.datetime later": {"year": 2025, "month": 6, "day": 15},
+    }
+
+    code = WiringCompiler(spec, thread_safe=False).compile(aio=True)
+
+    # Verify code was generated (exact await handling is complex)
+    assert "async def now(self):" in code
+    assert "async def later(self):" in code
+
+
+def test_aio_compile_nested_call_replacement() -> None:
+    """Test _replace_awaits_with_locals in Call nodes."""
+    import sys
+    from types import ModuleType
+
+    from apywire import Spec, WiringCompiler
+
+    class MockMod(ModuleType):
+        def combine(
+            self, *args: object, **kwargs: object
+        ) -> dict[str, object]:
+            return {"args": args, **kwargs}
+
+    sys.modules["nested_call"] = MockMod("nested_call")
+
+    try:
+        spec: Spec = {
+            "nested_call.combine root": {
+                "x": "{a}",
+                "y": "{b}",
+            },
+            "nested_call.combine a": {},
+            "nested_call.combine b": {},
+        }
+        code = WiringCompiler(spec, thread_safe=False).compile(aio=True)
+
+        # Verify async code was generated with replaced awaits
+        assert "async def root(self):" in code
+        assert "__val_" in code
+
+    finally:
+        del sys.modules["nested_call"]
+
+
+def test_compile_constant_accessor_skip() -> None:
+    """Test that constant accessors skip already-parsed items."""
+    import sys
+    from types import ModuleType
+
+    from apywire import Spec, WiringCompiler
+
+    class MockMod(ModuleType):
+        pass
+
+    sys.modules["const_test"] = MockMod("const_test")
+
+    try:
+        # Mix of parsed wired objects and constants
+        spec: Spec = {
+            "datetime.datetime obj": {"year": 2025, "month": 1, "day": 1},
+            "const": "value",
+        }
+        code = WiringCompiler(spec, thread_safe=False).compile()
+
+        # Both should be in code
+        assert "def obj(self):" in code
+        assert "def const(self):" in code
+        assert "return 'value'" in code
+
+    finally:
+        del sys.modules["const_test"]