apywire 1.0.4__tar.gz → 1.0.6__tar.gz

{apywire-1.0.4/apywire.egg-info → apywire-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apywire
-Version: 1.0.4
+Version: 1.0.6
 Summary: A package to wire up objects
 Author-email: Alexandre Gomes Gaigalas <alganet@gmail.com>
 Maintainer-email: Alexandre Gomes Gaigalas <alganet@gmail.com>
@@ -33,7 +33,7 @@ Requires-Dist: mkdocs-autorefs; extra == "dev"
 Requires-Dist: mkdocs-material; extra == "dev"
 Requires-Dist: mkdocs; extra == "dev"
 Requires-Dist: mkdocstrings[python]; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
+Requires-Dist: mypy>=2.1; extra == "dev"
 Requires-Dist: pygments>=2.20; extra == "dev"
 Requires-Dist: pymdown-extensions>=10.21.2; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{apywire-1.0.4 → apywire-1.0.6}/apywire/__main__.py

@@ -23,6 +23,8 @@ from apywire.formats import (
 from apywire.generator import Generator
 from apywire.wiring import Spec
 
+_FORMAT_CHOICES: tuple[str, ...] = ("ini", "toml", "json")
+
 
 def cmd_generate(args: argparse.Namespace) -> int:
     """Handle the generate command."""
@@ -128,7 +130,7 @@ def main(argv: list[str] | None = None) -> int:
     generate_parser.add_argument(
         "--format",
         required=True,
-        choices=["ini", "toml", "json"],
+        choices=_FORMAT_CHOICES,
         metavar="FORMAT",
         help="Output format: ini, toml, or json (required)",
     )
@@ -158,7 +160,7 @@ def main(argv: list[str] | None = None) -> int:
     compile_parser.add_argument(
         "--format",
         required=True,
-        choices=["ini", "toml", "json"],
+        choices=_FORMAT_CHOICES,
         metavar="FORMAT",
         help="Input format: ini, toml, or json (required)",
     )

{apywire-1.0.4 → apywire-1.0.6}/apywire/compiler.py

@@ -452,7 +452,7 @@ class WiringCompiler(WiringBase):
         # Add import statements
         modules = set()
         for module_name, _, _, _ in self._parsed.values():
-            # Skip synthetic __pconst__ module
+            # Skip the synthetic __sconst__ module (SYNTHETIC_CONST)
             if module_name != SYNTHETIC_CONST:
                 modules.add(module_name)
         if thread_safe:

{apywire-1.0.4 → apywire-1.0.6}/apywire/constants.py

@@ -23,3 +23,8 @@ PLACEHOLDER_REGEX = re.compile(PLACEHOLDER_PATTERN)
 SYNTHETIC_CONST = "__sconst__"  # Synthetic module for promoted constants
 
 CACHE_ATTR_PREFIX = "_"  # Prefix for cache attributes (_name)
+
+# Thread-safety defaults: max retries and per-retry sleep when falling back
+# to the global lock in thread_safe mode.
+DEFAULT_MAX_LOCK_ATTEMPTS = 10
+DEFAULT_LOCK_RETRY_SLEEP = 0.01

{apywire-1.0.4 → apywire-1.0.6}/apywire/formats.py

@@ -8,8 +8,8 @@ from __future__ import annotations
 
 import configparser
 import json
-from types import ModuleType
 from collections.abc import Mapping
+from types import ModuleType
 from typing import cast
 
 from apywire.exceptions import FormatError
@@ -311,15 +311,12 @@ def json_to_spec(content: str) -> Spec:
     try:
         raw: object = json.loads(content)
     except Exception as e:
-        raise FormatError(
-            "json", f"Failed to parse JSON content: {e}"
-        ) from e
+        raise FormatError("json", f"Failed to parse JSON content: {e}") from e
 
     if not isinstance(raw, dict):
         raise FormatError(
             "json",
-            "JSON root must be an object, "
-            f"got {type(raw).__name__}",
+            "JSON root must be an object, " f"got {type(raw).__name__}",
         )
 
     data: dict[str, object] = raw

{apywire-1.0.4 → apywire-1.0.6}/apywire/generator.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 import importlib
 import inspect
-from types import ModuleType, NoneType
+from types import ModuleType, NoneType, UnionType
 from typing import (
     Union,
     cast,
@@ -216,8 +216,11 @@ class Generator(SpecParser):
             tuple[object, ...], get_args(annotation)
         )
 
-        # Optional[X] is Union[X, None]
-        if origin is Union:
+        # Optional[X] / Union[X, None] (typing.Union) and the PEP 604 form
+        # X | None (types.UnionType). On Python < 3.14 get_origin returns a
+        # different object for each spelling, so both must be matched for
+        # `X | None` to be normalized like Optional[X].
+        if origin is Union or origin is UnionType:
             # Filter out NoneType
             non_none_args: list[object] = [
                 a for a in args if a is not type(None)

{apywire-1.0.4 → apywire-1.0.6}/apywire/runtime.py

@@ -16,6 +16,8 @@ from typing import Awaitable, Callable, Protocol, cast, final
 
 from apywire.constants import (
     CACHE_ATTR_PREFIX,
+    DEFAULT_LOCK_RETRY_SLEEP,
+    DEFAULT_MAX_LOCK_ATTEMPTS,
     PLACEHOLDER_REGEX,
     SYNTHETIC_CONST,
 )
@@ -67,8 +69,8 @@ class WiringRuntime(WiringBase, ThreadSafeMixin):
         spec: Spec,
         *,
         thread_safe: bool = False,
-        max_lock_attempts: int = 10,
-        lock_retry_sleep: float = 0.01,
+        max_lock_attempts: int = DEFAULT_MAX_LOCK_ATTEMPTS,
+        lock_retry_sleep: float = DEFAULT_LOCK_RETRY_SLEEP,
     ) -> None:
         """Initialize a WiringRuntime container.
 
@@ -91,8 +93,8 @@ class WiringRuntime(WiringBase, ThreadSafeMixin):
 
     def _init_thread_safety(
         self,
-        max_lock_attempts: int = 10,
-        lock_retry_sleep: float = 0.01,
+        max_lock_attempts: int = DEFAULT_MAX_LOCK_ATTEMPTS,
+        lock_retry_sleep: float = DEFAULT_LOCK_RETRY_SLEEP,
     ) -> None:
         """Initialize thread safety mixin."""
         ThreadSafeMixin._init_thread_safety(
@@ -101,8 +103,31 @@ class WiringRuntime(WiringBase, ThreadSafeMixin):
 
     def __getattr__(self, name: str) -> Accessor:
         """Return a callable accessor for the named wired object."""
+        # Read internal state from __dict__ directly. __getattr__ only runs
+        # when normal lookup fails, so referencing self._parsed/self._values
+        # here would re-enter __getattr__ and recurse forever whenever they
+        # are absent (e.g. during copy/unpickle or a partially-failed
+        # __init__). Failing cleanly with AttributeError lets those protocols
+        # work and keeps errors meaningful.
+        # object.__getattribute__ does the normal C-level lookup and raises
+        # AttributeError directly if the attribute is absent, WITHOUT calling
+        # __getattr__ again -- so missing internal state fails cleanly instead
+        # of recursing.
+        try:
+            parsed = cast(
+                "dict[str, object]",
+                object.__getattribute__(self, "_parsed"),
+            )
+            values = cast(
+                "dict[str, object]",
+                object.__getattribute__(self, "_values"),
+            )
+        except AttributeError:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{name}'"
+            ) from None
         # If the name is in our parsed spec or constants, return an accessor.
-        if name in self._parsed or name in self._values:
+        if name in parsed or name in values:
             return Accessor(self, name)
         raise AttributeError(
             f"'{type(self).__name__}' object has no attribute '{name}'"
@@ -208,18 +233,29 @@ class WiringRuntime(WiringBase, ThreadSafeMixin):
             self._values[name] = result
             return result
 
-        module = importlib.import_module(entry.module_name)
-        cls = cast(_Constructor, getattr(module, entry.class_name))
+        # Resolving the module, class and factory method is part of THIS
+        # attribute's instantiation, so any failure here (missing module,
+        # class or factory method) is wrapped with this attribute's name.
+        # Wrapping these consistently makes thread-safe and non-thread-safe
+        # modes report identical errors for every failure mode.
+        try:
+            module = importlib.import_module(entry.module_name)
+            cls = cast(_Constructor, getattr(module, entry.class_name))
 
-        # If a factory method is specified, get it from the class
-        if entry.factory_method:
-            constructor = cast(
-                _Constructor, getattr(cls, entry.factory_method)
-            )
-        else:
-            constructor = cls
+            # If a factory method is specified, get it from the class
+            if entry.factory_method:
+                constructor = cast(
+                    _Constructor, getattr(cls, entry.factory_method)
+                )
+            else:
+                constructor = cls
+        except Exception as e:
+            raise WiringError(f"failed to instantiate '{name}': {e}") from e
 
-        # Resolve arguments
+        # Resolve arguments. Nested instantiation failures surface here as
+        # WiringErrors that already name the dependency that failed; let them
+        # propagate unchanged rather than re-wrapping them with this
+        # attribute's name (which would bury the real origin).
         kwargs = self._resolve_runtime(entry.data, context=name)
 
         try:
@@ -360,13 +396,20 @@ class AioAccessor:
 
     def __getattr__(self, name: str) -> Callable[[], Awaitable[object]]:
         """Return an async callable for the named wired object."""
+        # Read _wiring from __dict__ to avoid recursing through __getattr__
+        # if this accessor isn't fully initialized.
+        try:
+            wiring = cast(
+                WiringRuntime, object.__getattribute__(self, "_wiring")
+            )
+        except AttributeError:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{name}'"
+            ) from None
         # Check if valid name
-        if (
-            name not in self._wiring._parsed
-            and name not in self._wiring._values
-        ):
+        if name not in wiring._parsed and name not in wiring._values:
             raise AttributeError(
-                f"'{type(self._wiring).__name__}' object has no attribute "
+                f"'{type(wiring).__name__}' object has no attribute "
                 f"'{name}'"
             )
 
@@ -404,8 +447,16 @@ class CompiledAio:
 
     def __getattr__(self, name: str) -> Callable[[], Awaitable[object]]:
         """Return an async callable for the named accessor."""
+        # Read _compiled from __dict__ to avoid recursing through __getattr__
+        # if this wrapper isn't fully initialized.
+        try:
+            compiled = cast(object, object.__getattribute__(self, "_compiled"))
+        except AttributeError:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{name}'"
+            ) from None
         method: Callable[[], object] = cast(
-            Callable[[], object], getattr(self._compiled, name)
+            Callable[[], object], getattr(compiled, name)
         )
         cache_attr = f"{CACHE_ATTR_PREFIX}{name}"
 

{apywire-1.0.4 → apywire-1.0.6}/apywire/threads.py

@@ -15,7 +15,11 @@ import threading
 import time
 from typing import Callable, Literal, NoReturn, cast
 
-from apywire.constants import CACHE_ATTR_PREFIX
+from apywire.constants import (
+    CACHE_ATTR_PREFIX,
+    DEFAULT_LOCK_RETRY_SLEEP,
+    DEFAULT_MAX_LOCK_ATTEMPTS,
+)
 from apywire.exceptions import LockUnavailableError
 
 
@@ -47,8 +51,8 @@ class ThreadSafeMixin:
 
     def _init_thread_safety(
         self,
-        max_lock_attempts: int = 10,
-        lock_retry_sleep: float = 0.01,
+        max_lock_attempts: int = DEFAULT_MAX_LOCK_ATTEMPTS,
+        lock_retry_sleep: float = DEFAULT_LOCK_RETRY_SLEEP,
     ) -> None:
         """Initialize thread safety primitives.
 
@@ -113,16 +117,20 @@ class ThreadSafeMixin:
         This helper method provides consistent error wrapping for all
         instantiation paths, avoiding code duplication.
 
+        A `WiringError` (including its `UnknownPlaceholderError` and
+        `CircularWiringError` subtypes) is already wrapped with proper
+        context by the instantiation logic, so it is re-raised unchanged.
+        Re-wrapping it here would double-wrap the error and discard the
+        original message/cause, making thread-safe failures less informative
+        than their non-thread-safe equivalents.
+
         This method always raises an exception and never returns.
         """
-        from apywire.exceptions import (
-            UnknownPlaceholderError,
-            WiringError,
-        )
+        from apywire.exceptions import WiringError
 
-        if isinstance(e, UnknownPlaceholderError):
+        if isinstance(e, WiringError):
             raise
-        # All other exceptions (including WiringError) are wrapped
+        # Any other exception is wrapped to add the attribute-name context.
         raise WiringError(f"failed to instantiate '{name}'") from e
 
     def _instantiate_attr(
@@ -159,13 +167,20 @@ class ThreadSafeMixin:
                     try:
                         inst = maker()
                     except LockUnavailableError:
-                        # On optimistic failure, release the lock and fall
-                        # through to global path
-                        lock.release()
-                        held.clear()
+                        # On optimistic failure, release ALL locks held by
+                        # this thread (this attribute's lock plus any
+                        # per-attribute locks acquired by successful nested
+                        # instantiations earlier in the chain), then fall
+                        # through to the global path. Releasing only `lock`
+                        # here would leak the nested locks and deadlock other
+                        # threads.
+                        self._release_held_locks()
                     except Exception as e:
-                        # Release lock before propagating exception
-                        lock.release()
+                        # Release ALL locks held by this thread before
+                        # propagating, for the same reason as above: nested
+                        # instantiations that succeeded earlier in the chain
+                        # still hold their per-attribute locks.
+                        self._release_held_locks()
                         self._wrap_instantiation_error(e, name)
                     else:
                         # Store in cache