pyagentic-core 1.2.0__tar.gz → 1.2.1__tar.gz

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentic-core
-Version: 1.2.0
+Version: 1.2.1
 Summary: Build LLM Agents in a Pythonic way
 Author-email: Ryan Mikulec <rmikulec.dev@gmail.com>
 License: MIT

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/pyagentic/_base/_context.py

@@ -210,7 +210,4 @@ class ContextRef:
         val = context
         for part in self.path.split("."):
             val = getattr(val, part)
-            # if it’s wrapped in our Context helper, drill into .value
-            if hasattr(val, "value"):
-                val = val.value
         return val() if callable(val) else val

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/pyagentic/_base/_metaclasses.py

@@ -1,7 +1,8 @@
 import inspect
 from typing import dataclass_transform, TypeVar
-from typeguard import check_type
+from typeguard import check_type, TypeCheckError
 
+from pyagentic._base._validation import _AgentConstructionValidator
 from pyagentic._base._exceptions import SystemMessageNotDeclared, UnexpectedContextItemType
 from pyagentic._base._context import _AgentContext, ContextItem, computed_context
 from pyagentic._base._tool import _ToolDefinition
@@ -98,18 +99,25 @@ class AgentMeta(type):
             of different tasks.
         """
 
-        def __init__(self, *args, **kwargs):  # type: ignore
+        def __init__(self, *args, **kwargs):
+
+            # -------- ContextClass Construction --------------------
             ContextClass = _AgentContext.make_ctx_class(
                 name=self.__class__.__name__, ctx_map=self.__context_attrs__
             )
 
             context_kwargs = {}
             for attr_name, (attr_type, attr_default) in self.__context_attrs__.items():
+                # Skip compted contexts, this validaiton will happen with the validator
+                #   using a dry run with supplied default values
                 if attr_type == computed_context:
                     continue
+                # Add all ContextItems to the kwargs, checking type as it goes
                 if attr_name in kwargs:
                     val = kwargs[attr_name]
-                    if not check_type(val, attr_type):
+                    try:
+                        check_type(val, attr_type)
+                    except TypeCheckError:
                         raise UnexpectedContextItemType(
                             name=attr_name, expected=attr_type, recieved=type(val)
                         )
@@ -124,6 +132,8 @@ class AgentMeta(type):
             )
 
             bound = sig.bind(self, *args, **kwargs)
+
+            # Add all other arguements to instance
             for name, val in list(bound.arguments.items())[1:]:  # skip 'self'
                 if name in self.__context_attrs__:
                     pass
@@ -135,29 +145,35 @@ class AgentMeta(type):
         return __init__
 
     def __new__(mcs, name, bases, namespace, **kwargs):
+        # Create a new Agent class
         cls = super().__new__(mcs, name, bases, namespace, **kwargs)
-
+        # If it is a base Agent, then return
         if namespace.get("__abstract_base__", False):
             return cls
-
+        # Verify system message is set
         if "__system_message__" not in namespace:
             raise SystemMessageNotDeclared()
-
+        # Attach tool definitions
         cls.__tool_defs__ = mcs._extract_tool_defs(namespace)
-
+        # Attach new annotations
         cls.__annotations__ = mcs._extract_annotations(bases, namespace)
-
+        # Attach context attributes (ContextItems and computed_context)
         cls.__context_attrs__ = mcs._extract_context_attrs(cls.__annotations__, namespace)
-
+        # Create tool response models
         cls.__tool_response_models__ = {
             tool_name: ToolResponse.from_tool_def(tool_def)
             for tool_name, tool_def in cls.__tool_defs__.items()
         }
+        # Create final Agent response model, using the tool response models
         cls.__response_model__ = AgentResponse.from_tool_defs(
             cls.__name__, list(cls.__tool_response_models__.values())
         )
 
+        # Build the new init
         sig = mcs._build_init_signature(cls)
-
         cls.__init__ = mcs._build_init(sig)
+
+        # Validate agent
+        _AgentConstructionValidator(cls).validate()
+
         return cls

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/pyagentic/_base/_params.py

@@ -2,8 +2,11 @@ from dataclasses import dataclass
 from collections import defaultdict
 from typing import get_type_hints, Any, List, Dict, Type
 
+from typeguard import check_type, TypeCheckError
+
 from pyagentic._base._resolver import ContextualMixin, MaybeContext
 from pyagentic._base._context import _AgentContext
+from pyagentic._utils._typing import analyze_type, TypeCategory
 
 # simple mapping from Python types to JSON Schema/OpenAI types
 _TYPE_MAP: Dict[Type[Any], str] = {
@@ -83,29 +86,37 @@ class Param:
             TypeError: if a provided value does not match the annotated type,
                        or if unexpected fields are passed.
         """
-        cls = type(self)
-        hints = get_type_hints(cls)
-
-        # Assign annotated fields
-        for name, typ in hints.items():
-            if name in kwargs:
-                value = kwargs.pop(name)
-                # simple type check
-                if not isinstance(value, typ) and value is not None:
-                    raise TypeError(f"Field '{name}' expected {typ}, got {type(value)}")
-                setattr(self, name, value)
-            else:
-                # use class‐level default if given, else None
-                attr = getattr(cls, name, None)
-                if isinstance(attr, ParamInfo):
-                    default = attr.default
-                else:
-                    default = attr
-                setattr(self, name, default)
-
-        if kwargs:
-            unexpected = ", ".join(kwargs)
-            raise TypeError(f"Unexpected fields for {cls.__name__}: {unexpected}")
+        for field_name, (field_type, field_info) in self.__attributes__.items():
+            type_info = analyze_type(field_type, self.__class__.__bases__[0])
+            value = kwargs.get(field_name, field_info.default)
+
+            try:
+                if not type_info.is_subclass:
+                    check_type(value, field_type)
+            except TypeCheckError:
+                raise TypeError(f"Field '{field_name}' expected {field_type}, got {type(value)}")
+
+            match type_info.category:
+
+                case TypeCategory.PRIMITIVE:
+                    setattr(self, field_name, value)
+                case TypeCategory.LIST_PRIMITIVE:
+                    setattr(self, field_name, value)
+                case TypeCategory.SUBCLASS:
+                    value = field_type(**value) if type(value) == dict else value
+                    setattr(self, field_name, value)
+                case TypeCategory.LIST_SUBCLASS:
+                    listed_value = (
+                        [type_info.inner_type(**param_kwargs) for param_kwargs in value]
+                        if isinstance(value, list) and all(isinstance(v, dict) for v in value)
+                        else value
+                    )
+                    setattr(self, field_name, listed_value)
+
+        unexpected_args = [kwarg for kwarg in kwargs if kwarg not in self.__attributes__]
+        if unexpected_args:
+            unexpected = ", ".join(unexpected_args)
+            raise TypeError(f"Unexpected fields for {self.__class__.__name__}: {unexpected}")
 
     def __repr__(self):
         vals = ", ".join(f"{k}={v!r}" for k, v in self.dict().items())

pyagentic_core-1.2.1/pyagentic/_base/_resolver.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, fields, replace
+from typing import Annotated, TypeVar, get_origin, get_args, Any, Self
+
+from typeguard import check_type, TypeCheckError
+
+from pyagentic._base._context import _AgentContext, ContextRef
+from pyagentic._base._exceptions import InvalidContextRefMismatchTyping
+
+
+class _CtxMarker:
+    pass
+
+
+T = TypeVar("T")
+MaybeContext = Annotated[T, _CtxMarker()]
+
+
+@dataclass
+class ContextualMixin:
+    """
+    Class to be extended if any of the properties in the class may use a `ContextRef`. Gives the
+    subclass access to `resolve`, which allows a context to be passed in to backfill any
+    context-ready properties
+    """
+
+    @classmethod
+    def _get_maybe_context(cls):
+        maybe_contexts = []
+        for field in fields(cls):
+            type_ = field.type
+            # only look at Annotated[...] with our marker
+            if get_origin(type_) is Annotated and any(
+                isinstance(m, _CtxMarker) for m in get_args(type_)[1:]
+            ):
+                maybe_contexts.append(field)
+        return maybe_contexts
+
+    def resolve(self, ctx: _AgentContext) -> Self:
+        updates: dict[str, Any] = {}
+        for field in self._get_maybe_context():
+            raw = getattr(self, field.name)
+            if isinstance(raw, ContextRef):
+                value = ctx.get(raw.path)
+                # expected type is the first Annotated arg
+                expected_type = get_args(field.type)[0]
+                try:
+                    check_type(value, expected_type)
+                except TypeCheckError:
+                    raise InvalidContextRefMismatchTyping(
+                        ref_path=raw.path,
+                        field_name=field.name,
+                        recieved_type=type(value),
+                        expected_type=expected_type,
+                    )
+                updates[field.name] = value
+        # return a new instance with those fields replaced
+        return replace(self, **updates)

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/pyagentic/_base/_tool.py

@@ -1,11 +1,13 @@
 import inspect
-from typing import Callable, Any, TypeVar, get_type_hints, get_args, get_origin
+from typing import Callable, Any, TypeVar, get_type_hints
 from collections import defaultdict
 
 from pyagentic._base._params import Param, ParamInfo, _TYPE_MAP
 from pyagentic._base._context import _AgentContext
 from pyagentic._base._exceptions import ToolDeclarationFailed
 
+from pyagentic._utils._typing import TypeCategory, analyze_type
+
 
 class _ToolDefinition:
     """
@@ -49,19 +51,24 @@ class _ToolDefinition:
         required = []
 
         for name, (type_, default) in self.parameters.items():
-            if get_origin(type_) == list:
-                listed_type = get_args(type_)[0]
-                if issubclass(listed_type, Param):
-                    params[name] = {"type": "array", "items": listed_type.to_openai(context)}
-                else:
+            type_info = analyze_type(type_, Param)
+
+            match type_info.category:
+                case TypeCategory.PRIMITIVE:
+                    params[name] = {"type": _TYPE_MAP.get(type_, "string")}
+                case TypeCategory.LIST_PRIMITIVE:
                     params[name] = {
                         "type": "array",
-                        "items": {"type": _TYPE_MAP.get(listed_type, "string")},
+                        "items": {"type": _TYPE_MAP.get(type_info.inner_type, "string")},
                     }
-            elif issubclass(type_, Param):
-                params[name] = type_.to_openai(context)
-            else:
-                params[name] = {"type": _TYPE_MAP.get(type_, "string")}
+                case TypeCategory.SUBCLASS:
+                    params[name] = type_.to_openai(context)
+                case TypeCategory.LIST_SUBCLASS:
+                    params[name] = {
+                        "type": "array",
+                        "items": type_info.inner_type.to_openai(context),
+                    }
+
             if isinstance(default, ParamInfo):
                 resolved_default = default.resolve(context)
                 if resolved_default.description:
@@ -97,18 +104,20 @@ class _ToolDefinition:
 
         for name, (type_, info) in self.parameters.items():
             if name in kwargs:
-                if get_origin(type_) == list:
-                    listed_type = get_args(type_)[0]
-                    if issubclass(listed_type, Param):
-                        list_ = [type_(**param_args) for param_args in kwargs[name]]
-                    else:
-                        list_ = kwargs[name]
-                    compiled_args[name] = list_
-                elif issubclass(type_, Param):
-                    param_args = kwargs[name]
-                    compiled_args[name] = type_(**param_args)
-                else:
-                    compiled_args[name] = kwargs[name]
+                type_info = analyze_type(type_, Param)
+
+                match type_info.category:
+                    case TypeCategory.PRIMITIVE:
+                        compiled_args[name] = kwargs[name]
+                    case TypeCategory.LIST_PRIMITIVE:
+                        compiled_args[name] = kwargs[name]
+                    case TypeCategory.SUBCLASS:
+                        param_args = kwargs[name]
+                        compiled_args[name] = type_(**param_args)
+                    case TypeCategory.LIST_SUBCLASS:
+                        compiled_args[name] = [
+                            type_info.inner_type(**param_args) for param_args in kwargs[name]
+                        ]
             else:
                 compiled_args[name] = info.default
 

pyagentic_core-1.2.1/pyagentic/_base/_validation.py

@@ -0,0 +1,115 @@
+from typing import Type, get_args
+from typeguard import check_type, TypeCheckError
+
+from pyagentic._base._context import ContextItem, ContextRef
+
+
+# Temp class for typing
+class Agent:
+    pass
+
+
+class AgentValidationError(Exception):
+    def __init__(self, problems):
+        message = "Agent failed to be validated: \n"
+        message += "\n".join(problems)
+        super().__init__(message)
+
+
+class _AgentConstructionValidator:
+    """
+    Class to hold validation logic that needs to be checked at runtime
+
+    Class works by using default values to construct a sample agent, then runs additional checks
+        that could not be run on creation of the class
+    """
+
+    def __init__(self, AgentClass: Type["Agent"]):
+        self.problems = []
+        self.AgentClass = AgentClass
+        self.sample_agent = self.AgentClass(
+            model="testing",
+            api_key="validation",
+        )
+
+    def validate(self):
+        """
+        Validate an Agent class
+
+        Raises:
+            AgentValidationError: A custom exception that includes all problems found in the
+                validation pipelines
+        """
+        self._verify_default_values(self.AgentClass)
+        self._verify_context_items_can_be_strings(self.AgentClass)
+        self._verify_tool_context_refs(self.AgentClass)
+
+        if self.problems:
+            raise AgentValidationError(self.problems)
+
+    def _verify_tool_context_refs(self, AgentClass: Type["Agent"]):
+        """
+        Verifies that all context refs used:
+            - links to an item in the context
+            - The linked context item has the same type as the field it is being used in
+        """
+        for tool_name, tool_def in AgentClass.__tool_defs__.items():
+            for param_name, (param_type, param_info) in tool_def.parameters.items():
+                for info_field in param_info._get_maybe_context():
+                    attr = getattr(param_info, info_field.name)
+                    expected_type = get_args(info_field.type)[0]
+                    if isinstance(attr, ContextRef):
+                        if attr.path not in AgentClass.__context_attrs__:
+                            self.problems.append(
+                                f"tool.{tool_name}.param.{param_name}.{info_field.name}: Ref not found in context: {attr.path}"  # noqa E501
+                            )
+                        sample_value = self.sample_agent.context.get(attr.path)
+                        try:
+                            check_type(sample_value, expected_type)
+                        except TypeCheckError:
+                            self.problems.append(
+                                (
+                                    f"tool.{tool_name}.param.{param_name}.{info_field.name}: Ref typing does not match param info field:\n"  # noqa E501
+                                    f"  Expected: {expected_type}\n"
+                                    f"  Recieved: {type(sample_value).__name__}\n"
+                                )
+                            )
+
+    def _verify_context_items_can_be_strings(self, AgentClass: Type["Agent"]):
+        """
+        Verifies that all items in the context can be injected / used in the system message or
+            input template
+        """
+        for context_name in AgentClass.__context_attrs__.keys():
+            sample_value = self.sample_agent.context.get(context_name)
+            try:
+                str(sample_value)
+            except Exception:
+                self.problems.append(
+                    (
+                        f"context.{context_name}: Value cannot be stringified"
+                        f"  Value type: {type(sample_value)}"
+                    )
+                )
+
+    def _verify_default_values(self, AgentClass: Type["Agent"]):
+        """
+        Verifies that default values and default factories have the same type as to that
+            specified by the user
+        """
+        defaults = {}
+        for context_name, (context_type, context_item) in AgentClass.__context_attrs__.items():
+            if isinstance(context_item, ContextItem):
+                default = context_item.get_default_value()
+                try:
+                    check_type(default, context_type)
+                except TypeCheckError:
+                    self.problems.append(
+                        (
+                            f"context.{context_name}: Default value does not match context item typing:\n"  # noqa E501
+                            f"  Expected: {context_type}\n"
+                            f"  Recieved: {type(default)}\n"
+                        )
+                    )
+                defaults[context_name] = default
+        return defaults

pyagentic_core-1.2.1/pyagentic/_utils/_typing.py

@@ -0,0 +1,73 @@
+from typing import get_origin, get_args, Any, Optional
+from dataclasses import dataclass
+from enum import Enum
+
+
+PRIMITIVES = (bool, str, int, float, type(None))
+
+
+def is_primitive(type_: Any) -> bool:
+    """
+    Helper function to check if a type is a python primitive
+    """
+    return type_ in PRIMITIVES
+
+
+class TypeCategory(Enum):
+    PRIMITIVE = "primitive"
+    LIST_PRIMITIVE = "list_primitive"
+    SUBCLASS = "subclass"
+    LIST_SUBCLASS = "list_subclass"
+    UNSUPPORTED = "unsupported"
+
+
+@dataclass
+class TypeInfo:
+    """Normalized information about a type"""
+
+    category: TypeCategory
+    base_type: type
+    inner_type: Optional[type] = None  # For list types
+
+    @property
+    def is_list(self) -> bool:
+        return self.category in [TypeCategory.LIST_PRIMITIVE, TypeCategory.LIST_SUBCLASS]
+
+    @property
+    def is_subclass(self) -> bool:
+        return self.category in [TypeCategory.SUBCLASS, TypeCategory.LIST_SUBCLASS]
+
+    @property
+    def effective_type(self) -> type:
+        """Returns the type to work with (inner type for lists, base type otherwise)"""
+        return self.inner_type if self.is_list else self.base_type
+
+
+def analyze_type(type_: type, base_class: type) -> TypeInfo:
+    """
+    Analyze a type and return normalized information about it.
+
+    Args:
+        type_: The type to analyze
+        is_primitive_func: Function to check if a type is primitive
+        param_base_class: Base class for Param types (e.g., Param)
+    """
+    origin = get_origin(type_)
+
+    if origin == list:
+        inner_type = get_args(type_)[0]
+        if is_primitive(inner_type):
+            return TypeInfo(TypeCategory.LIST_PRIMITIVE, type_, inner_type)
+        elif issubclass(inner_type, base_class):
+            return TypeInfo(TypeCategory.LIST_SUBCLASS, type_, inner_type)
+        else:
+            return TypeInfo(TypeCategory.UNSUPPORTED, type_, inner_type)
+
+    elif is_primitive(type_):
+        return TypeInfo(TypeCategory.PRIMITIVE, type_)
+
+    elif issubclass(type_, base_class):
+        return TypeInfo(TypeCategory.SUBCLASS, type_)
+
+    else:
+        return TypeInfo(TypeCategory.UNSUPPORTED, type_)

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/pyagentic/models/response.py

@@ -1,20 +1,12 @@
 from pydantic import BaseModel, Field, create_model
-from typing import Any, Type, get_origin, get_args, Self, Union
+from typing import Type, Self, Union
 
 from openai.types.responses import Response
 
 from pyagentic._base._tool import _ToolDefinition
 from pyagentic._base._params import Param
 
-
-PRIMITIVES = (bool, str, int, float, type(None))
-
-
-def is_primitive(type_: Any) -> bool:
-    """
-    Helper function to check if a type is a python primitive
-    """
-    return type_ in PRIMITIVES
+from pyagentic._utils._typing import TypeCategory, analyze_type
 
 
 def param_to_pydantic(ParamClass: Type[Param]) -> Type[BaseModel]:
@@ -30,36 +22,36 @@ def param_to_pydantic(ParamClass: Type[Param]) -> Type[BaseModel]:
     fields = {}
 
     for attr_name, (attr_type, attr_info) in ParamClass.__attributes__.items():
-        if get_origin(attr_type) == list:
-            origin_type = get_args(attr_type)[0]
-            if is_primitive(origin_type):
+        type_info = analyze_type(attr_type, Param)
+
+        match type_info.category:
+
+            case TypeCategory.PRIMITIVE:
+                fields[attr_name] = (
+                    attr_type,
+                    Field(default=attr_info.default, description=attr_info.description),
+                )
+            case TypeCategory.LIST_PRIMITIVE:
                 fields[attr_name] = (
                     list[attr_type],
                     Field(default=attr_info.default, description=attr_info.description),
                 )
-            elif issubclass(origin_type, Param):
-                SubParamModel = param_to_pydantic(origin_type)
+            case TypeCategory.SUBCLASS:
+                SubParamModel = param_to_pydantic(attr_type)
+                fields[attr_name] = (
+                    SubParamModel,
+                    Field(default=attr_info.default, description=attr_info.description),
+                )
+            case TypeCategory.LIST_SUBCLASS:
+                SubParamModel = param_to_pydantic(type_info.inner_type)
                 fields[attr_name] = (
                     list[SubParamModel],
                     Field(default=attr_info.default, description=attr_info.description),
                 )
-            else:
+            case _:
                 raise Exception(f"Unsupported type: {attr_type}")
-        elif is_primitive(attr_type):
-            fields[attr_name] = (
-                attr_type,
-                Field(default=attr_info.default, description=attr_info.description),
-            )
-        elif issubclass(attr_type, Param):
-            SubParamModel = param_to_pydantic(attr_type)
-            fields[attr_name] = (
-                SubParamModel,
-                Field(default=attr_info.default, description=attr_info.description),
-            )
-        else:
-            raise Exception(f"Unsupported type: {attr_type}")
 
-    return create_model(f"{ParamClass.__name__}", **fields)
+    return create_model(f"{ParamClass.__name__}Model", **fields)
 
 
 class ToolResponse(BaseModel):
@@ -82,20 +74,33 @@ class ToolResponse(BaseModel):
         """
         fields = {}
         for param_name, (param_type, param_info) in tool_def.parameters.items():
-            if get_origin(param_type) == list:
-                pass
-            elif is_primitive(param_type):
-                fields[param_name] = (
-                    param_type,
-                    Field(default=param_info.default, description=param_info.description),
-                )
-            elif issubclass(param_type, Param):
-                fields[param_name] = (
-                    param_to_pydantic(param_type),
-                    Field(default=param_info.default, description=param_info.description),
-                )
-            else:
-                raise Exception(f"Unsupported type: {param_type}")
+            type_info = analyze_type(param_type, Param)
+            match type_info.category:
+
+                case TypeCategory.PRIMITIVE:
+                    fields[param_name] = (
+                        param_type,
+                        Field(default=param_info.default, description=param_info.description),
+                    )
+                case TypeCategory.LIST_PRIMITIVE:
+                    fields[param_name] = (
+                        param_type,
+                        Field(default=param_info.default, description=param_info.description),
+                    )
+                case TypeCategory.SUBCLASS:
+                    ParamSubModel = param_to_pydantic(param_type)
+                    fields[param_name] = (
+                        ParamSubModel,
+                        Field(default=param_info.default, description=param_info.description),
+                    )
+                case TypeCategory.LIST_SUBCLASS:
+                    ParamSubModel = param_to_pydantic(type_info.inner_type)
+                    fields[param_name] = (
+                        list[ParamSubModel],
+                        Field(default=param_info.default, description=param_info.description),
+                    )
+                case _:
+                    raise Exception(f"Unsupported type: {param_type}")
 
         return create_model(f"ToolResponse[{tool_def.name}]", __base__=cls, **fields)
 

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/pyagentic_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentic-core
-Version: 1.2.0
+Version: 1.2.1
 Summary: Build LLM Agents in a Pythonic way
 Author-email: Ryan Mikulec <rmikulec.dev@gmail.com>
 License: MIT

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/pyagentic_core.egg-info/SOURCES.txt

@@ -12,6 +12,8 @@ pyagentic/_base/_metaclasses.py
 pyagentic/_base/_params.py
 pyagentic/_base/_resolver.py
 pyagentic/_base/_tool.py
+pyagentic/_base/_validation.py
+pyagentic/_utils/_typing.py
 pyagentic/models/response.py
 pyagentic_core.egg-info/PKG-INFO
 pyagentic_core.egg-info/SOURCES.txt

{pyagentic_core-1.2.0 → pyagentic_core-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyagentic-core"
-version = "1.2.0"
+version = "1.2.1"
 description = "Build LLM Agents in a Pythonic way"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -25,6 +25,7 @@ dependencies = [
 [dependency-groups]
 dev = [
     "black>=25.1.0",
+    "coverage>=7.10.2",
     "deepdiff>=8.5.0",
     "flake8>=7.3.0",
     "pytest>=8.4.1",

pyagentic_core-1.2.0/pyagentic/_base/_resolver.py

@@ -1,51 +0,0 @@
-from dataclasses import dataclass, fields, replace
-from typing import Annotated, TypeVar, get_origin, get_args, Any, Self
-
-from typeguard import check_type, TypeCheckError
-
-from pyagentic._base._context import _AgentContext, ContextRef
-from pyagentic._base._exceptions import InvalidContextRefMismatchTyping
-
-
-class _CtxMarker:
-    pass
-
-
-T = TypeVar("T")
-MaybeContext = Annotated[T, _CtxMarker()]
-
-
-@dataclass
-class ContextualMixin:
-    """
-    Class to be extended if any of the properties in the class may use a `ContextRef`. Gives the
-    subclass access to `resolve`, which allows a context to be passed in to backfill any
-    context-ready properties
-    """
-
-    def resolve(self, ctx: _AgentContext) -> Self:
-        updates: dict[str, Any] = {}
-        for f in fields(self):
-            tp = f.type
-            # only look at Annotated[...] with our marker
-            if get_origin(tp) is Annotated and any(
-                isinstance(m, _CtxMarker) for m in get_args(tp)[1:]
-            ):
-
-                raw = getattr(self, f.name)
-                if isinstance(raw, ContextRef):
-                    value = ctx.get(raw.path)
-                    # expected type is the first Annotated arg
-                    expected_type = get_args(tp)[0]
-                    try:
-                        check_type(value, expected_type)
-                    except TypeCheckError:
-                        raise InvalidContextRefMismatchTyping(
-                            ref_path=raw.path,
-                            field_name=f.name,
-                            recieved_type=type(value),
-                            expected_type=expected_type,
-                        )
-                    updates[f.name] = value
-                    # return a new instance with those fields replaced
-        return replace(self, **updates)