Support constant interpolation

  - Allows one constant to use another
  - Automatically promotes a constant to an Accessor if that constant
    tries to interpolate an object. Will use `__str__` for the
    object string representation.
  - Tests.

Author: alganet

apywire/compiler.py

@@ -15,6 +15,7 @@
     CACHE_ATTR_PREFIX,
     COMPILED_ARG_PREFIX,
     COMPILED_VAR_PREFIX,
+    SYNTHETIC_CONST,
 )
 from apywire.wiring import (
     WiringBase,
@@ -551,7 +552,9 @@ def compile(self, *, aio: bool = False, thread_safe: bool = False) -> str:
         # Add import statements
         modules = set()
         for module_name, _, _, _ in self._parsed.values():
-            modules.add(module_name)
+            # Skip synthetic __pconst__ module
+            if module_name != SYNTHETIC_CONST:
+                modules.add(module_name)
         if aio:
             modules.add("asyncio")
         if thread_safe:
@@ -620,13 +623,19 @@ def compile(self, *, aio: bool = False, thread_safe: bool = False) -> str:
             factory_method,
             data,
         ) in self._parsed.items():
+            # Skip synthetic auto-promoted constants
+            # These require runtime interpolation and can't be pre-computed
+            if module_name == SYNTHETIC_CONST and class_name == "str":
+                continue
+
+            # Regular wired object
             class_body.append(
                 self._compile_property(
                     name,
                     module_name,
                     class_name,
                     factory_method,
-                    data,
+                    cast(_ResolvedSpecMapping, data),
                     aio=aio,
                     thread_safe=thread_safe,
                 )

apywire/constants.py

@@ -19,6 +19,20 @@
 PLACEHOLDER_END = "}"
 """End marker for placeholder references in spec values."""
 
+# Placeholder regex pattern (compiled for efficiency)
+PLACEHOLDER_PATTERN = r"\{([^{}]+)\}"
+"""Regex pattern for matching placeholders like {name}.
+
+Matches placeholder syntax with the following rules:
+- Starts with { and ends with }
+- Captures the placeholder name (group 1)
+- Does not allow nested braces in the name
+- Example: "{host}" matches with name="host"
+"""
+
+SYNTHETIC_CONST = "__sconst__"
+"""Synthetic module name used to represent promoted constants."""
+
 # Cache attribute constants
 CACHE_ATTR_PREFIX = "_"
 """Prefix for cache attributes on compiled/runtime instances."""

apywire/runtime.py

@@ -9,8 +9,10 @@
 
 import asyncio
 import importlib
+import re
 from typing import Awaitable, Callable, Protocol, cast, final
 
+from apywire.constants import SYNTHETIC_CONST
 from apywire.exceptions import (
     CircularWiringError,
     UnknownPlaceholderError,
@@ -205,6 +207,14 @@ def _instantiate_impl(self, name: str) -> _RuntimeValue:
                 )
 
             module_name, class_name, factory_method, data = self._parsed[name]
+
+            # Check for synthetic auto-promoted constant
+            if module_name == SYNTHETIC_CONST and class_name == "str":
+                # This is an auto-promoted constant with string interpolation
+                value = self._format_string_constant(data, context=name)
+                self._values[name] = value
+                return value
+
             module = importlib.import_module(module_name)
             cls = cast(_Constructor, getattr(module, class_name))
 
@@ -271,6 +281,55 @@ def _resolve_runtime(
             return tuple(self._resolve_runtime(v, context) for v in o)
         return o
 
+    def _format_string_constant(
+        self, template: _ResolvedValue, context: str
+    ) -> str:
+        """Format a string constant with wired object interpolation.
+
+        Converts template like "Server {host} at {now}" by:
+        1. Finding all placeholders in the string
+        2. Resolving each to its wired object or constant
+        3. Converting to string via str()
+        4. Performing string interpolation
+
+        Args:
+            template: Template string with placeholders
+            context: Name of the constant being formatted (for error messages)
+
+        Returns:
+            Fully formatted string with all placeholders resolved
+
+        Raises:
+            WiringError: If template is not a string
+            UnknownPlaceholderError: If placeholder references unknown object
+        """
+        # Template should be a string
+        if not isinstance(template, str):
+            raise WiringError(
+                f"Auto-promoted constant '{context}' template is not a string"
+            )
+
+        # Build lookup dict that resolves wired objects on access
+        # We can't use _interpolate_placeholders directly because we need
+        # to call getattr() for wired objects, not just lookup in a dict
+        def replace_placeholder(match: re.Match[str]) -> str:
+            ref_name = match.group(1)
+
+            # Check if the referenced name exists
+            if ref_name not in self._values and ref_name not in self._parsed:
+                raise UnknownPlaceholderError(
+                    f"Unknown placeholder '{ref_name}' "
+                    f"in auto-promoted constant '{context}'"
+                )
+
+            # Get the value (instantiate if needed via accessor)
+            value = cast(object, getattr(self, ref_name)())
+
+            # Convert to string
+            return str(value)
+
+        return re.sub(self._placeholder_pattern, replace_placeholder, template)
+
 
 @final
 class Accessor: