python-introspect 0.1.14__py3-none-any.whl → 0.2.2__py3-none-any.whl

python_introspect/__init__.py

@@ -9,7 +9,7 @@ Extensibility:
     type resolution for framework-specific types (lazy configs, proxies, etc.)
 """
 
-__version__ = "0.1.12"
+__version__ = "0.2.2"
 
 from .signature_analyzer import (
     SignatureAnalyzer,
@@ -24,7 +24,6 @@ from .signature_analyzer import (
 )
 from .unified_parameter_analyzer import (
     UnifiedParameterAnalyzer,
-    UnifiedParameterInfo,
     add_parameter_exclusions,
     set_parameter_exclusions,
     parameter_exclusions,
@@ -51,6 +50,19 @@ from .dataclass_projection import (
     dataclass_from_mapping,
     project_dataclass,
 )
+from .jsonable import (
+    JsonObject,
+    JsonScalar,
+    JsonValue,
+    to_jsonable,
+)
+from .public_api import (
+    declared_public_names,
+    exported_public_names,
+    is_declared_public_name,
+    lazy_exports,
+    public_names_from_objects,
+)
 from .environment_projection import (
     EnvironmentVariable,
     overlay_dataclass_from_environment,
@@ -89,7 +101,6 @@ __all__ = [
     "signature_analysis_target",
     # Unified analysis
     "UnifiedParameterAnalyzer",
-    "UnifiedParameterInfo",
     "add_parameter_exclusions",
     "set_parameter_exclusions",
     "parameter_exclusions",
@@ -111,6 +122,17 @@ __all__ = [
     # Dataclass projection
     "dataclass_from_mapping",
     "project_dataclass",
+    # JSON-native projection
+    "JsonObject",
+    "JsonScalar",
+    "JsonValue",
+    "to_jsonable",
+    # Module public surfaces
+    "declared_public_names",
+    "exported_public_names",
+    "is_declared_public_name",
+    "lazy_exports",
+    "public_names_from_objects",
     # Environment projection
     "EnvironmentVariable",
     "overlay_dataclass_from_environment",

python_introspect/annotation_types.py

@@ -2,9 +2,54 @@
 
 from __future__ import annotations
 
+import sys
 import types
 from enum import Enum
-from typing import Annotated, Union, get_args, get_origin
+from typing import Annotated, Literal, Union, get_args, get_origin, get_type_hints
+
+
+def resolved_class_annotations(owner: type) -> dict[str, object]:
+    """Resolve nested type strings in the class that declared each field.
+
+    Python 3.10 leaves strings inside PEP 585 aliases unresolved. Complete
+    those declarations without interpreting Literal values or Annotated metadata.
+    """
+    annotations = get_type_hints(owner, include_extras=True)
+    unresolved = set(annotations)
+    for declaration in owner.__mro__:
+        class_namespace = dict(vars(declaration))
+        module = sys.modules.get(declaration.__module__)
+        module_namespace = {} if module is None else vars(module)
+        for name in class_namespace.get("__annotations__", {}):
+            if name in unresolved:
+                annotations[name] = _resolve_nested_type_strings(
+                    annotations[name], class_namespace, module_namespace
+                )
+                unresolved.remove(name)
+    return annotations
+
+
+def _resolve_nested_type_strings(annotation: object, globalns: dict, localns: dict) -> object:
+    if isinstance(annotation, str):
+        return _resolve_nested_type_strings(eval(annotation, globalns, localns), globalns, localns)
+    if isinstance(annotation, list):
+        resolved = [_resolve_nested_type_strings(member, globalns, localns) for member in annotation]
+        return annotation if all(a is b for a, b in zip(resolved, annotation)) else resolved
+    origin = get_origin(annotation)
+    members = get_args(annotation)
+    if not members or origin is Literal:
+        return annotation
+    if origin is Annotated:
+        base = _resolve_nested_type_strings(members[0], globalns, localns)
+        return annotation if base is members[0] else Annotated[(base, *members[1:])]
+    resolved = tuple(_resolve_nested_type_strings(member, globalns, localns) for member in members)
+    if all(member is original for member, original in zip(resolved, members)):
+        return annotation
+    if isinstance(annotation, types.GenericAlias):
+        return types.GenericAlias(origin, resolved)
+    if is_union_type(annotation):
+        return Union[resolved]  # noqa: UP007 - dynamically derived member tuple
+    return origin[resolved]
 
 
 def is_union_type(annotation: object) -> bool:

python_introspect/dataclass_projection.py

@@ -13,10 +13,9 @@ from typing import (
     TypeVar,
     get_args,
     get_origin,
-    get_type_hints,
 )
 
-from .annotation_types import is_union_type
+from .annotation_types import is_union_type, resolved_class_annotations
 from .validation import validate_annotated_dataclass, validate_annotation_value
 
 DataclassT = TypeVar("DataclassT")
@@ -26,7 +25,11 @@ def dataclass_from_mapping(
     target_type: type[DataclassT],
     values: Mapping[str, object],
 ) -> DataclassT:
-    """Construct one dataclass from the fields declared by its class."""
+    """Construct declared init fields and verify supplied constructor-owned fields.
+
+    Non-init fields belong to the dataclass's defaults or post-init behavior,
+    not the input mapping. If supplied, they must agree with that owner.
+    """
 
     if not isinstance(target_type, type) or not is_dataclass(target_type):
         raise TypeError(
@@ -41,9 +44,7 @@ def dataclass_from_mapping(
             f"got {non_text_keys!r}."
         )
 
-    declared_fields = tuple(
-        declared_field for declared_field in fields(target_type) if declared_field.init
-    )
+    declared_fields = fields(target_type)
     declared_names = {declared_field.name for declared_field in declared_fields}
     extras = tuple(sorted(set(values) - declared_names))
     if extras:
@@ -51,19 +52,20 @@ def dataclass_from_mapping(
             f"{target_type.__name__} received undeclared field(s): {', '.join(extras)}."
         )
 
-    annotations = get_type_hints(target_type, include_extras=True)
-    constructor_values: dict[str, object] = {}
+    annotations = resolved_class_annotations(target_type)
+    decoded_values: dict[str, object] = {}
     missing: list[str] = []
     for declared_field in declared_fields:
         if declared_field.name not in values:
             if (
-                declared_field.default is MISSING
+                declared_field.init
+                and declared_field.default is MISSING
                 and declared_field.default_factory is MISSING
             ):
                 missing.append(declared_field.name)
             continue
         annotation = annotations.get(declared_field.name, declared_field.type)
-        constructor_values[declared_field.name] = _mapping_value_for_annotation(
+        decoded_values[declared_field.name] = _mapping_value_for_annotation(
             annotation,
             values[declared_field.name],
             path=f"{target_type.__name__}.{declared_field.name}",
@@ -73,8 +75,23 @@ def dataclass_from_mapping(
             f"{target_type.__name__} is missing required field(s): {', '.join(missing)}."
         )
 
-    result = target_type(**constructor_values)
+    result = target_type(
+        **{
+            declared_field.name: decoded_values[declared_field.name]
+            for declared_field in declared_fields
+            if declared_field.init and declared_field.name in decoded_values
+        }
+    )
     validate_annotated_dataclass(result)
+    for declared_field in declared_fields:
+        if not declared_field.init and declared_field.name in decoded_values:
+            if decoded_values[declared_field.name] != object.__getattribute__(
+                result, declared_field.name
+            ):
+                raise ValueError(
+                    f"{target_type.__name__}.{declared_field.name} disagrees with "
+                    "its constructed value."
+                )
     return result
 
 

python_introspect/jsonable.py

@@ -0,0 +1,120 @@
+"""JSON-native projection of declared Python values.
+
+``to_jsonable`` is the encoder paired with ``dataclass_from_mapping``: a
+dataclass projects through its declared fields, and the decoder rebuilds it
+from the same declarations. Further value types join through
+``to_jsonable.register``.
+"""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable, Mapping
+from dataclasses import fields, is_dataclass
+from enum import Enum
+from functools import singledispatch
+from pathlib import Path
+from typing import ForwardRef, TypeAlias
+
+from metaclass_registry import AutoRegisterMeta
+
+from .signature_analyzer import signature_analysis_target
+
+JsonScalar: TypeAlias = str | int | float | bool | None
+# Recursive aliases retain this declaration's namespace when imported by
+# dataclasses; get_type_hints evaluates the reference in this module.
+_JSON_VALUE_REFERENCE = ForwardRef("JsonValue", module=__name__)
+JsonValue: TypeAlias = (
+    JsonScalar
+    | Mapping[str, _JSON_VALUE_REFERENCE]
+    | tuple[_JSON_VALUE_REFERENCE, ...]
+    | list[_JSON_VALUE_REFERENCE]
+)
+JsonObject: TypeAlias = Mapping[str, JsonValue]
+
+
+def _jsonable_dataclass(value: object) -> JsonValue:
+    """Project fields without ``asdict`` deep-copying immutable containers."""
+
+    return {
+        declared_field.name: to_jsonable(getattr(value, declared_field.name))
+        for declared_field in fields(value)
+    }
+
+
+@singledispatch
+def to_jsonable(value: object) -> JsonValue:
+    """Project dataclasses and registered values into JSON-native data."""
+
+    if is_dataclass(value) and not isinstance(value, type):
+        return _jsonable_dataclass(value)
+    raise TypeError(f"Value is not JSON-serializable: {type(value).__name__}")
+
+
+@to_jsonable.register(Mapping)
+def _jsonable_mapping(value: Mapping) -> JsonValue:
+    return {str(to_jsonable(key)): to_jsonable(item) for key, item in value.items()}
+
+
+@to_jsonable.register(tuple)
+@to_jsonable.register(list)
+@to_jsonable.register(set)
+@to_jsonable.register(frozenset)
+def _jsonable_sequence(value) -> JsonValue:
+    return [to_jsonable(item) for item in value]
+
+
+@to_jsonable.register(Callable)
+def _jsonable_callable(value: Callable[..., object]) -> JsonValue:
+    if is_dataclass(value) and not isinstance(value, type):
+        return _jsonable_dataclass(value)
+    target = signature_analysis_target(value)
+    module = inspect.getmodule(target)
+    module_name = type(target).__module__ if module is None else module.__name__
+    if inspect.isfunction(target) or inspect.ismethod(target) or inspect.isclass(target):
+        qualname = target.__qualname__
+    else:
+        qualname = type(target).__qualname__
+    return {
+        "kind": "callable",
+        "name": qualname.rsplit(".", 1)[-1],
+        "module": module_name,
+        "qualname": qualname,
+        "import_path": f"{module_name}.{qualname}",
+    }
+
+
+@to_jsonable.register(AutoRegisterMeta)
+def _jsonable_registered_type(value: AutoRegisterMeta) -> JsonValue:
+    key_attribute = value.__registry_key__
+    declaring_owner = next(
+        (owner for owner in value.__mro__ if key_attribute in vars(owner)),
+        None,
+    )
+    if declaring_owner is None:
+        raise TypeError(
+            f"Registered type {value.__qualname__} has no declared " f"{key_attribute!r} key."
+        )
+    key = vars(declaring_owner)[key_attribute]
+    if key is None:
+        raise TypeError(f"Registered type {value.__qualname__} has no registry key.")
+    return to_jsonable(key)
+
+
+@to_jsonable.register(Enum)
+def _jsonable_enum(value: Enum) -> JsonValue:
+    return to_jsonable(value.value)
+
+
+@to_jsonable.register(Path)
+def _jsonable_path(value: Path) -> JsonValue:
+    return str(value)
+
+
+@to_jsonable.register(type(None))
+@to_jsonable.register(str)
+@to_jsonable.register(int)
+@to_jsonable.register(float)
+@to_jsonable.register(bool)
+def _jsonable_scalar(value) -> JsonValue:
+    return value

python_introspect/public_api.py

@@ -0,0 +1,111 @@
+"""Module public surfaces derived from what a module declares."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from importlib import import_module
+from inspect import isclass, isfunction
+from types import ModuleType
+from typing import Any
+
+
+def declared_public_names(
+    module_globals: Mapping[str, object],
+    *,
+    constant_prefixes: Iterable[str] = (),
+    excluded_names: Iterable[str] = (),
+    extra_names: Iterable[str] = (),
+) -> tuple[str, ...]:
+    """Return public names declared by the module represented by globals()."""
+    module_name = module_globals["__name__"]
+    prefixes = tuple(constant_prefixes)
+    excluded = set(excluded_names)
+    declared_names = tuple(
+        name
+        for name, value in module_globals.items()
+        if name not in excluded
+        if is_declared_public_name(
+            module_name,
+            name,
+            value,
+            constant_prefixes=prefixes,
+        )
+    )
+    return declared_names + tuple(name for name in extra_names if name not in excluded)
+
+
+def exported_public_names(
+    module_globals: Mapping[str, object],
+    *,
+    excluded_names: Iterable[str] = (),
+) -> tuple[str, ...]:
+    """Return public re-export names declared by explicit module imports."""
+    excluded = set(excluded_names)
+    return tuple(
+        name
+        for name, value in module_globals.items()
+        if not name.startswith("_")
+        if name not in excluded
+        if not isinstance(value, ModuleType)
+    )
+
+
+def public_names_from_objects(*objects: Any, extra_names: Iterable[str] = ()) -> tuple[str, ...]:
+    """Return public names from exported object identities plus explicit aliases."""
+    return tuple(item if isinstance(item, str) else item.__name__ for item in objects) + tuple(
+        extra_names
+    )
+
+
+def is_declared_public_name(
+    module_name: str,
+    name: str,
+    value: object,
+    *,
+    constant_prefixes: tuple[str, ...] = (),
+) -> bool:
+    """Return whether a global is a public module declaration."""
+    if name.startswith("_"):
+        return False
+    if name.isupper():
+        return any(name.startswith(prefix) for prefix in constant_prefixes)
+    return (isclass(value) or isfunction(value)) and value.__module__ == module_name
+
+
+def lazy_exports(
+    module_globals: dict[str, object],
+    exports: Mapping[str, Iterable[str]],
+) -> tuple[str, ...]:
+    """Install PEP 562 ``__getattr__``/``__dir__`` resolving names on first access.
+
+    ``exports`` maps each owning module path (absolute, or relative to the
+    package whose ``globals()`` are passed) to the names it supplies. A name is
+    imported from its owner on first access and cached in the module globals.
+    Returns the exported names in declaration order, for ``__all__``.
+    """
+
+    module_name = module_globals["__name__"]
+    package = module_globals.get("__package__") or module_name
+    owners: dict[str, str] = {}
+    for owner, names in exports.items():
+        for name in names:
+            if name in owners:
+                raise ValueError(
+                    f"{module_name} lazy export {name!r} is declared by both "
+                    f"{owners[name]!r} and {owner!r}."
+                )
+            owners[name] = owner
+
+    def __getattr__(name: str) -> object:
+        if name not in owners:
+            raise AttributeError(f"module {module_name!r} has no attribute {name!r}")
+        value = getattr(import_module(owners[name], package), name)
+        module_globals[name] = value
+        return value
+
+    def __dir__() -> list[str]:
+        return sorted(set(module_globals) | set(owners))
+
+    module_globals["__getattr__"] = __getattr__
+    module_globals["__dir__"] = __dir__
+    return tuple(owners)

python_introspect/signature_analyzer.py

@@ -9,10 +9,13 @@ resolvers to extend functionality without modifying this code.
 
 import ast
 import inspect
+import sys
+import linecache
+from functools import lru_cache
 import dataclasses
 import re
 from abc import ABC, abstractmethod
-from typing import Annotated, Any, Dict, Callable, get_type_hints, NamedTuple, Union, Optional, Type, List, ClassVar, Tuple, get_args, get_origin
+from typing import Annotated, Any, Dict, Callable, get_type_hints, NamedTuple, Union, Optional, Type, List, ClassVar, Tuple, get_args, get_origin, Iterable
 from weakref import WeakKeyDictionary
 
 from dataclasses import dataclass, field
@@ -143,13 +146,71 @@ class AnalysisConstants:
 CONSTANTS = AnalysisConstants()
 
 
-class ParameterInfo(NamedTuple):
-    """Information about a parameter."""
+@dataclass(frozen=True, init=False, eq=False)
+class ParameterInfo:
+    """Admitted parameter values with presentation derived from their declaration.
+
+    Callable descriptions remain concrete because they can determine inferred
+    types. Dataclass descriptions are requested independently of value admission.
+    """
+
     name: str
     param_type: type
     default_value: Any
     is_required: bool
-    description: Optional[str] = None  # Add parameter description from docstring
+    _description: Optional[str]
+    _description_owner: Optional[type]
+
+    def __init__(
+        self, name: str, param_type: type, default_value: Any, is_required: bool,
+        description: Optional[str] = None, *, description_owner: Optional[type] = None,
+    ):
+        object.__setattr__(self, "name", name)
+        object.__setattr__(self, "param_type", param_type)
+        object.__setattr__(self, "default_value", default_value)
+        object.__setattr__(self, "is_required", is_required)
+        object.__setattr__(self, "_description", description)
+        object.__setattr__(self, "_description_owner", description_owner)
+
+    @property
+    def description(self) -> Optional[str]:
+        if self._description_owner is not None:
+            SignatureAnalyzer._materialize_dataclass_descriptions(self._description_owner, self)
+        return self._description
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ParameterInfo):
+            return NotImplemented
+        return (
+            self.name, self.param_type, self.default_value, self.is_required, self.description,
+        ) == (
+            other.name, other.param_type, other.default_value, other.is_required, other.description,
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.param_type, self.default_value, self.is_required, self.description))
+
+    def _replace(self, **changes: Any) -> "ParameterInfo":
+        """Replace declared fields through the same public parameter owner."""
+        values = dict(
+            name=self.name, param_type=self.param_type,
+            default_value=self.default_value, is_required=self.is_required,
+            description=self._description,
+        )
+        unknown = changes.keys() - values.keys()
+        if unknown:
+            raise ValueError(f"Got unexpected field names: {sorted(unknown)!r}")
+        owner = self._description_owner
+        if "description" in changes:
+            owner = None
+        elif "name" in changes and changes["name"] != self.name:
+            # A renamed field keeps the original declaration's help, rather
+            # than querying a different field in the same source class.
+            values["description"] = self.description
+            owner = None
+        values.update(changes)
+        return type(self)(**values, description_owner=owner)
+
 
 class DocstringInfo(NamedTuple):
     """Information extracted from a docstring."""
@@ -434,12 +495,7 @@ class DocstringExtractor:
         if not docstring:
             return DocstringInfo(parameters={})
 
-        # Try AST-based parsing first for better accuracy
-        try:
-            return DocstringExtractor._parse_docstring_ast(actual_target, docstring)
-        except Exception:
-            # Fall back to regex-based parsing
-            return DocstringExtractor._parse_docstring(docstring)
+        return DocstringExtractor._parse_docstring(docstring)
 
     @staticmethod
     def _resolve_lazy_target(target: Union[Callable, type]) -> Union[Callable, type]:
@@ -448,38 +504,6 @@ class DocstringExtractor:
             return target
         return _resolve_type(target)
 
-    @staticmethod
-    def _parse_docstring_ast(target: Union[Callable, type], docstring: str) -> DocstringInfo:
-        """Parse docstring using AST for more accurate extraction.
-
-        This method uses AST to parse the source code and extract docstring
-        information more accurately, especially for complex multiline descriptions.
-        """
-        try:
-            # Get source code
-            source = inspect.getsource(target)
-            tree = ast.parse(source)
-
-            # Find the function/class node
-            for node in ast.walk(tree):
-                if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
-                    if ast.get_docstring(node) == docstring:
-                        return DocstringExtractor._parse_ast_docstring(node, docstring)
-
-            # Fallback to regex parsing if AST parsing fails
-            return DocstringExtractor._parse_docstring(docstring)
-
-        except Exception:
-            # Fallback to regex parsing
-            return DocstringExtractor._parse_docstring(docstring)
-
-    @staticmethod
-    def _parse_ast_docstring(node: Union[ast.FunctionDef, ast.ClassDef], docstring: str) -> DocstringInfo:
-        """Parse docstring from AST node with enhanced multiline support."""
-        # For now, use the improved regex parser
-        # This can be extended later with more sophisticated AST-based parsing
-        return DocstringExtractor._parse_docstring(docstring)
-
     @staticmethod
     def _parse_docstring(docstring: str) -> DocstringInfo:
         """Parse a docstring into structured components with improved multiline support.
@@ -747,6 +771,70 @@ class CallableAnalysisContext:
         )
 
 
+class ClassSourceDeclaration(NamedTuple):
+    """Immutable located class source and its source-only documentation views."""
+
+    source: str
+    inline_docs: Tuple[Tuple[str, Tuple[Tuple[str, str], ...]], ...]
+
+    @classmethod
+    def from_block(cls, source: str, tree: ast.AST, first_line: int = 1) -> "ClassSourceDeclaration":
+        # The public extractor historically parses the selected block without
+        # dedenting. Keep nested/local blocks' empty inline-documentation view.
+        first = next((line for line in source.splitlines() if line.strip()), '')
+        if first[:1].isspace():
+            return cls(source, ())
+        source_lines = source.split('\n')
+        declarations = []
+        for class_node in ast.walk(tree):
+            if not isinstance(class_node, ast.ClassDef):
+                continue
+            field_docs = {}
+
+            # Method 1: Look for field assignments followed by string literals (next line)
+            for i, node in enumerate(class_node.body):
+                if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+                    field_name = node.target.id
+
+                    # Check if the next node is a string literal (documentation)
+                    if i + 1 < len(class_node.body):
+                        next_node = class_node.body[i + 1]
+                        if isinstance(next_node, ast.Expr):
+                            if isinstance(next_node.value, ast.Constant) and isinstance(next_node.value.value, str):
+                                field_docs[field_name] = next_node.value.value.strip()
+                                continue
+
+                    # Method 2: Check for inline comments on the same line
+                    # Get the line number of the field definition
+                    field_line_num = node.lineno - first_line
+                    if 0 <= field_line_num < len(source_lines):
+                        line = source_lines[field_line_num]
+
+                        # Look for string literals in comments on the same line
+                        # Pattern: field: type = value  # """Documentation"""
+                        comment_match = re.search(r'#\s*["\']([^"\']+)["\']', line)
+                        if comment_match:
+                            field_docs[field_name] = comment_match.group(1).strip()
+                            continue
+
+                        # Look for triple-quoted strings on the same line
+                        # Pattern: field: type = value  """Documentation"""
+                        triple_quote_match = re.search(r'"""([^"]+)"""|\'\'\'([^\']+)\'\'\'', line)
+                        if triple_quote_match:
+                            doc_text = triple_quote_match.group(1) or triple_quote_match.group(2)
+                            field_docs[field_name] = doc_text.strip()
+
+            declarations.append((class_node.name, tuple(field_docs.items())))
+        return cls(source, tuple(declarations))
+
+    def field_documentation(self, class_name: str) -> Dict[str, str]:
+        """Return a fresh view selected by the caller's current public name."""
+        for name, entries in self.inline_docs:
+            if name == class_name:
+                return dict(entries)
+        return {}
+
+
 class SignatureAnalyzer:
     """Universal analyzer for extracting parameter information from any target."""
 
@@ -941,16 +1029,6 @@ class SignatureAnalyzer:
             except Exception:
                 type_hints = inspect.get_annotations(dataclass_type, eval_str=False)
 
-            # Extract docstring information from dataclass
-            docstring_info = DocstringExtractor.extract(dataclass_type)
-
-            # Extract inline field documentation using AST
-            inline_docs = SignatureAnalyzer._extract_inline_field_docs(dataclass_type)
-
-            # ENHANCEMENT: For dataclasses modified by decorators,
-            # also extract field documentation from the field types themselves
-            field_type_docs = SignatureAnalyzer._extract_field_type_docs(dataclass_type)
-
             parameters = {}
 
             for field in dataclasses.fields(dataclass_type):
@@ -971,31 +1049,12 @@ class SignatureAnalyzer:
                     default_value = None
                     is_required = True
 
-                # Get field description from multiple sources (priority order)
-                field_description = None
-
-                # 1. Field metadata (highest priority)
-                if 'description' in field.metadata:
-                    field_description = field.metadata['description']
-                # 2. Inline documentation strings (from AST parsing)
-                elif field.name in inline_docs:
-                    field_description = inline_docs[field.name]
-                # 3. Field type documentation (for decorator-modified classes)
-                elif field.name in field_type_docs:
-                    field_description = field_type_docs[field.name]
-                # 4. Docstring parameters (fallback)
-                elif docstring_info.parameters and field.name in docstring_info.parameters:
-                    field_description = docstring_info.parameters.get(field.name)
-                # 5. CRITICAL FIX: Use inheritance-aware field documentation extraction
-                else:
-                    field_description = SignatureAnalyzer.extract_field_documentation(dataclass_type, field.name)
-
                 parameters[field.name] = ParameterInfo(
                     name=field.name,
                     param_type=param_type,
                     default_value=default_value,
                     is_required=is_required,
-                    description=field_description
+                    description_owner=dataclass_type,
                 )
 
             # PERFORMANCE: Cache the result to avoid re-parsing
@@ -1006,6 +1065,152 @@ class SignatureAnalyzer:
             # Return empty dict on error (don't cache errors)
             return {}
 
+    @staticmethod
+    def _materialize_dataclass_descriptions(dataclass_type: type, requested: ParameterInfo) -> None:
+        """Fill presentation on the existing admitted declarations, once requested.
+
+        Presentation extraction errors no longer discard usable value/type
+        declarations. They yield absent help, matching the existing help fallback.
+        """
+        parameters = SignatureAnalyzer._dataclass_analysis_cache.get(dataclass_type, {})
+        admitted = parameters.get(requested.name)
+        if admitted is not None and admitted is not requested:
+            object.__setattr__(requested, "_description", admitted.description)
+            object.__setattr__(requested, "_description_owner", None)
+            return
+        if admitted is not requested:
+            parameters = {requested.name: requested}
+        pending = [info for info in parameters.values() if info._description_owner is not None]
+        if not pending:
+            return
+        try:
+            docstring_info = DocstringExtractor.extract(dataclass_type)
+            inline_docs = SignatureAnalyzer._extract_inline_field_docs(dataclass_type)
+            field_type_docs = SignatureAnalyzer._extract_field_type_docs(dataclass_type)
+            descriptions = {}
+            for field in dataclasses.fields(dataclass_type):
+                if field.name not in parameters:
+                    continue
+                if 'description' in field.metadata:
+                    description = field.metadata['description']
+                elif field.name in inline_docs:
+                    description = inline_docs[field.name]
+                elif field.name in field_type_docs:
+                    description = field_type_docs[field.name]
+                elif field.name in docstring_info.parameters_dict:
+                    description = docstring_info.parameters_dict[field.name]
+                else:
+                    description = SignatureAnalyzer.extract_field_documentation(dataclass_type, field.name)
+                descriptions[field.name] = description
+        except Exception:
+            descriptions = {}
+        for info in pending:
+            object.__setattr__(info, "_description", descriptions.get(info.name))
+            object.__setattr__(info, "_description_owner", None)
+
+    @staticmethod
+    def prepare_dataclass_declarations(declarations: Iterable[type]) -> None:
+        """Prepare source facts for declared schemas without resolving values.
+
+        MRO, raw annotations and declared dataclass defaults expose schema
+        relationships. Unresolved strings/ForwardRefs remain live for analysis;
+        factories, namespace providers and type resolvers are never invoked.
+        """
+        pending = list(declarations)
+        visited = set()
+        while pending:
+            declaration = pending.pop()
+            if not inspect.isclass(declaration) or declaration in visited:
+                continue
+            visited.add(declaration)
+            if declaration is object:
+                continue
+            if not dataclasses.is_dataclass(declaration):
+                continue
+            SignatureAnalyzer._extract_inline_field_docs(declaration)
+            pending.extend(
+                base for base in inspect.getmro(declaration)[1:]
+                if dataclasses.is_dataclass(base)
+            )
+            for declared_field in dataclasses.fields(declaration):
+                field_types = [declared_field.type]
+                while field_types:
+                    field_type = field_types.pop()
+                    if inspect.isclass(field_type) and dataclasses.is_dataclass(field_type):
+                        pending.append(field_type)
+                    field_types.extend(get_args(field_type))
+                if dataclasses.is_dataclass(declared_field.default):
+                    default = declared_field.default
+                    pending.append(default if inspect.isclass(default) else type(default))
+                factory = declared_field.default_factory
+                if inspect.isclass(factory) and dataclasses.is_dataclass(factory):
+                    pending.append(factory)
+
+    @staticmethod
+    def prepare_dataclass_declaration(dataclass_type: type) -> None:
+        """Prepare one declaration's source closure without evaluating defaults."""
+        SignatureAnalyzer.prepare_dataclass_declarations((dataclass_type,))
+
+    @staticmethod
+    def _dataclass_source(dataclass_type: type) -> ClassSourceDeclaration:
+        """Read current loader source, deriving its class block by immutable content."""
+        # Python 3.13+ locates class source from __firstlineno__ directly;
+        # its native locator does not perform the repeated module AST traversal.
+        if sys.version_info >= (3, 13):
+            source = inspect.getsource(dataclass_type)
+            if source[:1].isspace():
+                return ClassSourceDeclaration(source, ())
+            tree = SignatureAnalyzer._module_source_tree(source)
+            class_node = next((node for node in ast.walk(tree) if isinstance(node, ast.ClassDef)), None)
+            if class_node is None:
+                return ClassSourceDeclaration(source, ())
+            return SignatureAnalyzer._qualified_class_source(source, class_node.name)
+        target = inspect.unwrap(dataclass_type)
+        if not inspect.isclass(target):
+            source = inspect.getsource(target)
+            return ClassSourceDeclaration.from_block(source, SignatureAnalyzer._module_source_tree(source))
+        file = inspect.getsourcefile(target)
+        if file:
+            linecache.checkcache(file)
+        else:
+            file = inspect.getfile(target)
+            if not (file.startswith('<') and file.endswith('>')):
+                raise OSError('source code not available')
+        module = inspect.getmodule(target, file)
+        lines = linecache.getlines(file, module.__dict__) if module else linecache.getlines(file)
+        if not lines:
+            raise OSError('could not get source code')
+        source = SignatureAnalyzer._qualified_class_source(''.join(lines), target.__qualname__)
+        if source is None:
+            raise OSError('could not find class definition')
+        return source
+
+    @staticmethod
+    @lru_cache(maxsize=32)
+    def _module_source_tree(source: str) -> ast.AST:
+        """Parse current immutable module bytes once; never expose the retained AST."""
+        return ast.parse(source)
+
+    @staticmethod
+    @lru_cache(maxsize=256)
+    def _qualified_class_source(source: str, qualname: str) -> Optional[ClassSourceDeclaration]:
+        """Use Python's qualified class/decorator locator on current source content."""
+        tree = SignatureAnalyzer._module_source_tree(source)
+        finder = inspect._ClassFinder(qualname)
+        try:
+            finder.visit(tree)
+        except inspect.ClassFoundException as found:
+            lines = source.splitlines(keepends=True)
+            first_line = found.args[0] + 1
+            block = ''.join(inspect.getblock(lines[found.args[0]:]))
+            class_node = next(
+                node for node in ast.walk(tree)
+                if isinstance(node, ast.ClassDef)
+                and min([node.lineno, *(decorator.lineno for decorator in node.decorator_list)]) == first_line
+            )
+            return ClassSourceDeclaration.from_block(block, class_node, first_line)
+        return None
+
     @staticmethod
     def _extract_inline_field_docs(dataclass_type: type) -> Dict[str, str]:
         """Extract inline field documentation strings using AST parsing.
@@ -1033,84 +1238,22 @@ class SignatureAnalyzer:
             field_name: str = "default"
         """
         try:
-            import ast
-            import re
-
-            # Try to get source code - handle cases where it might not be available
-            source = None
             try:
-                source = inspect.getsource(dataclass_type)
+                declaration = SignatureAnalyzer._dataclass_source(dataclass_type)
             except (OSError, TypeError):
-                try:
-                    source_file = inspect.getfile(dataclass_type)
-                    with open(source_file, 'r', encoding='utf-8') as f:
-                        file_content = f.read()
-                    source = SignatureAnalyzer._extract_class_source_from_file(file_content, dataclass_type.__name__)
-                except Exception:
-                    pass
-
-            if not source:
-                return {}
-
-            tree = ast.parse(source)
-
-            # Find the class definition - be more flexible with class name matching
-            class_node = None
-            target_class_name = dataclass_type.__name__
-
-            # Handle cases where the class might have been renamed or modified
-            for node in ast.walk(tree):
-                if isinstance(node, ast.ClassDef):
-                    # Try exact match first
-                    if node.name == target_class_name:
-                        class_node = node
-                        break
-                    # Also try without common prefixes/suffixes that decorators might add
-
-            if not class_node:
-                return {}
-
-            field_docs = {}
-            source_lines = source.split('\n')
-
-            # Method 1: Look for field assignments followed by string literals (next line)
-            for i, node in enumerate(class_node.body):
-                if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
-                    field_name = node.target.id
-
-                    # Check if the next node is a string literal (documentation)
-                    if i + 1 < len(class_node.body):
-                        next_node = class_node.body[i + 1]
-                        if isinstance(next_node, ast.Expr):
-                            if isinstance(next_node.value, ast.Constant) and isinstance(next_node.value.value, str):
-                                field_docs[field_name] = next_node.value.value.strip()
-                                continue
-
-                    # Method 2: Check for inline comments on the same line
-                    # Get the line number of the field definition
-                    field_line_num = node.lineno - 1  # Convert to 0-based indexing
-                    if 0 <= field_line_num < len(source_lines):
-                        line = source_lines[field_line_num]
-
-                        # Look for string literals in comments on the same line
-                        # Pattern: field: type = value  # """Documentation"""
-                        comment_match = re.search(r'#\s*["\']([^"\']+)["\']', line)
-                        if comment_match:
-                            field_docs[field_name] = comment_match.group(1).strip()
-                            continue
-
-                        # Look for triple-quoted strings on the same line
-                        # Pattern: field: type = value  """Documentation"""
-                        triple_quote_match = re.search(r'"""([^"]+)"""|\'\'\'([^\']+)\'\'\'', line)
-                        if triple_quote_match:
-                            doc_text = triple_quote_match.group(1) or triple_quote_match.group(2)
-                            field_docs[field_name] = doc_text.strip()
-
-            return field_docs
-
+                source_file = inspect.getfile(dataclass_type)
+                with open(source_file, 'r', encoding='utf-8') as source_stream:
+                    source = SignatureAnalyzer._extract_class_source_from_file(
+                        source_stream.read(), dataclass_type.__name__
+                    )
+                if not source:
+                    return {}
+                declaration = SignatureAnalyzer._qualified_class_source(source, dataclass_type.__name__)
+                if declaration is None:
+                    return {}
+            return declaration.field_documentation(dataclass_type.__name__)
         except Exception:
-            # Return empty dict if AST parsing fails
-            # Could add logging here for debugging: logger.debug(f"AST parsing failed: {e}")
+            # Preserve the extractor's unavailable/unparsable-source boundary.
             return {}
 
     @staticmethod

python_introspect/unified_parameter_analyzer.py

@@ -13,7 +13,6 @@ import inspect
 import dataclasses
 from abc import ABC, abstractmethod
 from typing import Dict, Union, Callable, Type, Any, Optional, ClassVar
-from dataclasses import dataclass
 from weakref import WeakKeyDictionary
 
 from metaclass_registry import AutoRegisterMeta
@@ -59,29 +58,6 @@ def add_parameter_exclusions(
     set_parameter_exclusions(target, (*parameter_exclusions(target), *normalized))
 
 
-@dataclass
-class UnifiedParameterInfo:
-    """Unified parameter information that works for all parameter sources."""
-    name: str
-    param_type: Type
-    default_value: Any
-    is_required: bool
-    description: Optional[str] = None
-    source_type: str = "unknown"  # "function", "dataclass", "nested"
-    
-    @classmethod
-    def from_parameter_info(cls, param_info: ParameterInfo, source_type: str = "function") -> "UnifiedParameterInfo":
-        """Convert from existing ParameterInfo to unified format."""
-        return cls(
-            name=param_info.name,
-            param_type=param_info.param_type,
-            default_value=param_info.default_value,
-            is_required=param_info.is_required,
-            description=param_info.description,
-            source_type=source_type
-        )
-
-
 class UnifiedParameterTargetAnalyzer(ABC, metaclass=AutoRegisterMeta):
     """Nominal target-kind family for unified parameter analysis."""
 
@@ -91,7 +67,7 @@ class UnifiedParameterTargetAnalyzer(ABC, metaclass=AutoRegisterMeta):
     target_kind: ClassVar[Optional[str]] = None
 
     @classmethod
-    def analyze_target(cls, target: Union[Callable, Type, object]) -> Dict[str, UnifiedParameterInfo]:
+    def analyze_target(cls, target: Union[Callable, Type, object]) -> Dict[str, ParameterInfo]:
         """Analyze a target using the first registered target-kind analyzer."""
         for analyzer_cls in cls.__registry__.values():
             analyzer = analyzer_cls()
@@ -104,7 +80,7 @@ class UnifiedParameterTargetAnalyzer(ABC, metaclass=AutoRegisterMeta):
         """Return whether this analyzer owns the target."""
 
     @abstractmethod
-    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, UnifiedParameterInfo]:
+    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, ParameterInfo]:
         """Analyze the target."""
 
 
@@ -116,7 +92,7 @@ class CallableTargetAnalyzer(UnifiedParameterTargetAnalyzer):
     def matches(self, target: Union[Callable, Type, object]) -> bool:
         return callable(target) and not inspect.isclass(target)
 
-    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, UnifiedParameterInfo]:
+    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, ParameterInfo]:
         return UnifiedParameterAnalyzer._analyze_callable(target)
 
 
@@ -128,7 +104,7 @@ class DataclassTypeTargetAnalyzer(UnifiedParameterTargetAnalyzer):
     def matches(self, target: Union[Callable, Type, object]) -> bool:
         return inspect.isclass(target) and dataclasses.is_dataclass(target)
 
-    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, UnifiedParameterInfo]:
+    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, ParameterInfo]:
         return UnifiedParameterAnalyzer._analyze_dataclass_type(target)
 
 
@@ -140,7 +116,7 @@ class ClassTargetAnalyzer(UnifiedParameterTargetAnalyzer):
     def matches(self, target: Union[Callable, Type, object]) -> bool:
         return inspect.isclass(target)
 
-    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, UnifiedParameterInfo]:
+    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, ParameterInfo]:
         return UnifiedParameterAnalyzer._analyze_callable(target.__init__)
 
 
@@ -152,7 +128,7 @@ class DataclassInstanceTargetAnalyzer(UnifiedParameterTargetAnalyzer):
     def matches(self, target: Union[Callable, Type, object]) -> bool:
         return dataclasses.is_dataclass(target)
 
-    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, UnifiedParameterInfo]:
+    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, ParameterInfo]:
         return UnifiedParameterAnalyzer._analyze_dataclass_instance(target)
 
 
@@ -164,7 +140,7 @@ class ObjectInstanceTargetAnalyzer(UnifiedParameterTargetAnalyzer):
     def matches(self, target: Union[Callable, Type, object]) -> bool:
         return True
 
-    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, UnifiedParameterInfo]:
+    def analyze(self, target: Union[Callable, Type, object]) -> Dict[str, ParameterInfo]:
         return UnifiedParameterAnalyzer._analyze_object_instance(target)
 
 
@@ -177,7 +153,7 @@ class UnifiedParameterAnalyzer:
     """
     
     @staticmethod
-    def analyze(target: Union[Callable, Type, object], exclude_params: Optional[list] = None) -> Dict[str, UnifiedParameterInfo]:
+    def analyze(target: Union[Callable, Type, object], exclude_params: Optional[list] = None) -> Dict[str, ParameterInfo]:
         """Analyze parameters from any source.
 
         Args:
@@ -185,7 +161,7 @@ class UnifiedParameterAnalyzer:
             exclude_params: Optional list of parameter names to exclude from analysis
 
         Returns:
-            Dictionary mapping parameter names to UnifiedParameterInfo objects
+            Dictionary mapping parameter names to ParameterInfo objects
 
         Examples:
             # Function analysis
@@ -229,40 +205,17 @@ class UnifiedParameterAnalyzer:
         return frozenset(names)
     
     @staticmethod
-    def _analyze_callable(callable_obj: Callable) -> Dict[str, UnifiedParameterInfo]:
+    def _analyze_callable(callable_obj: Callable) -> Dict[str, ParameterInfo]:
         """Analyze a callable (function, method, etc.)."""
-        # Use existing SignatureAnalyzer for callables
-        param_info_dict = SignatureAnalyzer.analyze(callable_obj)
-
-        # Convert to unified format
-        unified_params = {}
-        for name, param_info in param_info_dict.items():
-            unified_params[name] = UnifiedParameterInfo.from_parameter_info(
-                param_info,
-                source_type="function"
-            )
-
-        return unified_params
-    
+        return SignatureAnalyzer.analyze(callable_obj)
+
     @staticmethod
-    def _analyze_dataclass_type(dataclass_type: Type) -> Dict[str, UnifiedParameterInfo]:
-        """Analyze a dataclass type using existing SignatureAnalyzer infrastructure."""
-        # CRITICAL FIX: Use existing SignatureAnalyzer._analyze_dataclass method
-        # which already handles all the docstring extraction properly
-        param_info_dict = SignatureAnalyzer._analyze_dataclass(dataclass_type)
-
-        # Convert to unified format
-        unified_params = {}
-        for name, param_info in param_info_dict.items():
-            unified_params[name] = UnifiedParameterInfo.from_parameter_info(
-                param_info,
-                source_type="dataclass"
-            )
-
-        return unified_params
+    def _analyze_dataclass_type(dataclass_type: Type) -> Dict[str, ParameterInfo]:
+        """Analyze a dataclass through its authoritative field declarations."""
+        return SignatureAnalyzer._analyze_dataclass(dataclass_type)
 
     @staticmethod
-    def _analyze_object_instance(instance: object) -> Dict[str, UnifiedParameterInfo]:
+    def _analyze_object_instance(instance: object) -> Dict[str, ParameterInfo]:
         """Analyze a regular object instance by examining its full inheritance hierarchy.
 
         For dynamic containers like SimpleNamespace (which use **kwargs in __init__),
@@ -295,8 +248,9 @@ class UnifiedParameterAnalyzer:
                 class_params = UnifiedParameterAnalyzer._analyze_callable(cls.__init__)
 
                 # Remove 'self' parameter
-                if 'self' in class_params:
-                    del class_params['self']
+                class_params = {
+                    name: info for name, info in class_params.items() if name != 'self'
+                }
 
                 _logger.debug(f"🔧 _analyze_object_instance: cls={cls.__name__}, class_params after removing self={list(class_params.keys())}")
 
@@ -312,14 +266,7 @@ class UnifiedParameterAnalyzer:
                 # Add parameters that haven't been seen yet (most specific wins)
                 for param_name, param_info in class_params.items():
                     if param_name not in all_params and param_name != 'kwargs':
-                        all_params[param_name] = UnifiedParameterInfo(
-                            name=param_name,
-                            param_type=param_info.param_type,
-                            default_value=param_info.default_value,
-                            is_required=param_info.is_required,
-                            description=param_info.description,
-                            source_type="object_instance"
-                        )
+                        all_params[param_name] = param_info
 
             except Exception:
                 # Skip classes that can't be analyzed - this is legitimate since some classes
@@ -337,67 +284,21 @@ class UnifiedParameterAnalyzer:
                     continue
                 # Infer type from value
                 attr_type = type(attr_value) if attr_value is not None else type(None)
-                all_params[attr_name] = UnifiedParameterInfo(
+                all_params[attr_name] = ParameterInfo(
                     name=attr_name,
                     param_type=attr_type,
                     default_value=attr_value,
                     is_required=False,
-                    description=None,
-                    source_type="dynamic_attr"
+                    description=None
                 )
             _logger.debug(f"🔧 _analyze_object_instance: after fallback, all_params={list(all_params.keys())}")
 
         return all_params
 
     @staticmethod
-    def _analyze_dataclass_instance(instance: object) -> Dict[str, UnifiedParameterInfo]:
+    def _analyze_dataclass_instance(instance: object) -> Dict[str, ParameterInfo]:
         """Analyze a dataclass instance.
 
         Uses current instance values as defaults.
         """
-        param_info_dict = SignatureAnalyzer.analyze(instance)
-        return {
-            name: UnifiedParameterInfo.from_parameter_info(
-                param_info,
-                source_type="dataclass_instance",
-            )
-            for name, param_info in param_info_dict.items()
-        }
-    
-    @staticmethod
-    def analyze_nested(
-        target: Union[Callable, Type, object],
-        parent_info: Dict[str, UnifiedParameterInfo] = None,
-    ) -> Dict[str, UnifiedParameterInfo]:
-        """Analyze parameters with nested dataclass support.
-        
-        This method provides enhanced analysis that can handle nested dataclasses
-        and maintain parent context information.
-        
-        Args:
-            target: The target to analyze
-            parent_info: Optional parent parameter information for context
-            
-        Returns:
-            Dictionary of unified parameter information with nested support
-        """
-        base_params = UnifiedParameterAnalyzer.analyze(target)
-        
-        # For each parameter, check if it's a nested dataclass
-        enhanced_params = {}
-        for name, param_info in base_params.items():
-            enhanced_params[name] = param_info
-            
-            # If this parameter is a dataclass, mark it as having nested structure
-            if dataclasses.is_dataclass(param_info.param_type):
-                # Update source type to indicate nesting capability
-                enhanced_params[name] = UnifiedParameterInfo(
-                    name=param_info.name,
-                    param_type=param_info.param_type,
-                    default_value=param_info.default_value,
-                    is_required=param_info.is_required,
-                    description=param_info.description,
-                    source_type=f"{param_info.source_type}_nested"
-                )
-        
-        return enhanced_params
+        return SignatureAnalyzer.analyze(instance)

python_introspect/validation.py

@@ -14,12 +14,11 @@ from typing import (
     TypeVar,
     get_args,
     get_origin,
-    get_type_hints,
 )
 
 from annotated_types import Ge, Gt, Interval, Le, Len, Lt, MaxLen, MinLen, Predicate
 
-from .annotation_types import is_union_type
+from .annotation_types import is_union_type, resolved_class_annotations
 
 
 class AnnotationValidationError(ValueError):
@@ -86,7 +85,7 @@ def validate_annotated_dataclass(instance: object) -> None:
             f"got {owner_type.__name__}."
         )
 
-    annotations = get_type_hints(owner_type, include_extras=True)
+    annotations = resolved_class_annotations(owner_type)
     for declared_field in fields(instance):
         annotation = annotations.get(declared_field.name, declared_field.type)
         value = object.__getattribute__(instance, declared_field.name)

{python_introspect-0.1.14.dist-info → python_introspect-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-introspect
-Version: 0.1.14
+Version: 0.2.2
 Summary: Pure Python introspection toolkit for function signatures, dataclasses, and type hints
 Author-email: Tristan Simas <tristan.simas@mail.mcgill.ca>
 License: MIT
@@ -24,6 +24,7 @@ Requires-Dist: annotated-types>=0.7.0
 Requires-Dist: metaclass-registry>=0.1.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: tomli>=2.0.1; python_version < "3.11" and extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: black>=23.0; extra == "dev"
@@ -94,3 +95,19 @@ changes are checked by the repository's [documentation
 workflow](https://github.com/OpenHCSDev/python-introspect/actions/workflows/docs.yml);
 the local warnings-as-errors build command is documented in
 [`development.rst`](docs/source/development.rst).
+
+### Parameter declarations in 0.2
+
+`UnifiedParameterAnalyzer` now returns the original `ParameterInfo` declarations
+from `SignatureAnalyzer`. `UnifiedParameterInfo`, its `source_type` tag, and
+`analyze_nested` were removed. Use `analyze` and the declared `param_type` for
+parameter topology.
+
+`ParameterInfo` retains its five public fields, constructor and `_replace`
+operation, and is now a frozen declaration rather than a tuple. Tuple unpacking
+and NamedTuple helpers are no longer supported. Dataclass descriptions are
+derived on first help access; value/default overlays preserve that deferred
+source, and renaming preserves the original field's help. Callable descriptions
+still participate eagerly in inferred parameter types. A presentation extraction
+error yields absent help without discarding valid types/defaults. Factory errors
+remain uncached and retryable.

python_introspect-0.2.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+python_introspect/__init__.py,sha256=IHmyKt23hfkRVeRaVD9mDuoWAG7Q7BorK-cP4B9o0Eg,3985
+python_introspect/annotation_types.py,sha256=KZDv0fUAuvVQDEj0U_cozA_31vl3MyNsOfSOcdo3aJk,7557
+python_introspect/callable_declaration.py,sha256=O7i0dGJP5rKWSlwfmmqlQLJwNQC_oSTngImVy3idaVE,1409
+python_introspect/dataclass_projection.py,sha256=531PIrAunWNuQBwnZDBRpDa0Gy8iK_F6B4ThwYqOhCU,10869
+python_introspect/docstring_annotations.py,sha256=RE6AZPgz8aBEIIvUoVEHpraItZfjareKxYvuaZa1H8k,6129
+python_introspect/enableable.py,sha256=Al6t1kpqbxZIvDb70XJPYEk1WgubGiWUQySNcBcLjrY,5253
+python_introspect/environment_projection.py,sha256=irfR4B6aRSnqC3fYmWpf7rlL3C6QXdYmOvso0RvCF6A,4654
+python_introspect/exceptions.py,sha256=TG8Vo2JdArBbL8hlHmfmt31LtEKtGAuFEh2Rh07DQHs,488
+python_introspect/jsonable.py,sha256=j-BlM6bc4Xm313eStqx2jCpkoennm76SaJNJj64DW7Q,3914
+python_introspect/public_api.py,sha256=8wkxQKmnxl_46U49Dzq4XXIOqmrYQOD0S0cl9bc-YFk,3738
+python_introspect/runtime_parameter.py,sha256=Wf7S1GfnUWhkRzIvjhmoYz2WR0HT2K_MuFDcUEphmJc,3067
+python_introspect/signature_analyzer.py,sha256=DlFaxudB-dANV0FD9MmLJWdvxBKobJbtEn5n6tda2JU,60926
+python_introspect/unified_parameter_analyzer.py,sha256=Qw39mQsYDYq5zEiB6ALRoZqwQeZ4PJmlkFxpTaKkccg,12231
+python_introspect/validation.py,sha256=vj3OwJFShA2n4Zg45rXj8qghsJxDe1JhND8gkuNbfLQ,10447
+python_introspect-0.2.2.dist-info/licenses/LICENSE,sha256=xagEoeTAj1WT64RmyR3E6HH-eTGdgXN6gqPMUUt7L_Y,1070
+python_introspect-0.2.2.dist-info/METADATA,sha256=rwnVJA2UW6z5V1pznJtSjYqb0-H9_Y55ynK00qji8SE,4677
+python_introspect-0.2.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_introspect-0.2.2.dist-info/top_level.txt,sha256=TZq9Yj1LeXI7A96PDqf7ZbWGSB1zLlQDww0esC91bwY,18
+python_introspect-0.2.2.dist-info/RECORD,,

python_introspect-0.1.14.dist-info/RECORD

@@ -1,17 +0,0 @@
-python_introspect/__init__.py,sha256=Xkk438372mA8C5CiG5oAOeuuClndjkTVEFmqKMOnTj0,3518
-python_introspect/annotation_types.py,sha256=3BJoeailgc6gdY7sTfGOwgxHykseE1q94jaZtlt5C94,5346
-python_introspect/callable_declaration.py,sha256=O7i0dGJP5rKWSlwfmmqlQLJwNQC_oSTngImVy3idaVE,1409
-python_introspect/dataclass_projection.py,sha256=gmYv-Oqk8q6zsz7dYauuVwIKfxOcOqOW2C3Oz4uAEWA,10105
-python_introspect/docstring_annotations.py,sha256=RE6AZPgz8aBEIIvUoVEHpraItZfjareKxYvuaZa1H8k,6129
-python_introspect/enableable.py,sha256=Al6t1kpqbxZIvDb70XJPYEk1WgubGiWUQySNcBcLjrY,5253
-python_introspect/environment_projection.py,sha256=irfR4B6aRSnqC3fYmWpf7rlL3C6QXdYmOvso0RvCF6A,4654
-python_introspect/exceptions.py,sha256=TG8Vo2JdArBbL8hlHmfmt31LtEKtGAuFEh2Rh07DQHs,488
-python_introspect/runtime_parameter.py,sha256=Wf7S1GfnUWhkRzIvjhmoYz2WR0HT2K_MuFDcUEphmJc,3067
-python_introspect/signature_analyzer.py,sha256=c2AOVGdTZAlk1LpTCP34CO06Sm8IVBfYrAdF2eJ0jtc,53781
-python_introspect/unified_parameter_analyzer.py,sha256=rFKrmX-zhUJZIGFEUejMdU_s4Bdrq0zJsTLq6MkwqxU,16284
-python_introspect/validation.py,sha256=Rvuni9Box1yJuRuqSly-jNypaS51ooXq92MRGD33e2Q,10448
-python_introspect-0.1.14.dist-info/licenses/LICENSE,sha256=xagEoeTAj1WT64RmyR3E6HH-eTGdgXN6gqPMUUt7L_Y,1070
-python_introspect-0.1.14.dist-info/METADATA,sha256=YbKYZ-SeidB0KOEpV_s69yM_AXttxBng6MeKvUNMmF4,3733
-python_introspect-0.1.14.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_introspect-0.1.14.dist-info/top_level.txt,sha256=TZq9Yj1LeXI7A96PDqf7ZbWGSB1zLlQDww0esC91bwY,18
-python_introspect-0.1.14.dist-info/RECORD,,