(tentative): fix warnings caused by model_copy()

Author: yaugenst-flex

tests/test_components/test_simulation.py

@@ -3667,12 +3667,12 @@ def test_messages_contain_object_names():
         polarization="Ex",
         source_time=td.GaussianPulse(freq0=100e14, fwidth=10e14),
     )
-    with pytest.raises(pydantic.ValidationError, match=name) as e:
+    with pytest.raises(ValidationError, match=name) as e:
         _ = sim.updated_copy(sources=[source])
 
     # Test 3) Create a monitor lying outside the simulation boundary.
     # Check that an error message is generated containing the monitor's `name`.
     name = "monitor_123"
     monitor = td.FieldMonitor(name=name, center=(-1.0, 0, 0), size=(0.5, 0, 1), freqs=[100e14])
-    with pytest.raises(pydantic.ValidationError, match=name) as e:
+    with pytest.raises(ValidationError, match=name) as e:
         _ = sim.updated_copy(monitors=[monitor])

tests/test_plugins/test_invdes.py

@@ -273,12 +273,12 @@ def test_invdes_multi_same_length():
     invdes = make_invdes_multi()
     n = len(invdes.simulations)
 
-    output_monitor_names = (n + 1) * [["test"]]
+    output_monitor_names = (n + 1) * [("test",)]
 
     with pytest.raises(ValueError):
         _ = invdes.updated_copy(output_monitor_names=output_monitor_names)
 
-    output_monitor_names = [([MNT_NAME1, MNT_NAME2], None)[i % 2] for i in range(n)]
+    output_monitor_names = [((MNT_NAME1, MNT_NAME2), None)[i % 2] for i in range(n)]
     invdes = invdes.updated_copy(output_monitor_names=output_monitor_names)
 
     _ = invdes.designs

tidy3d/components/autograd/types.py

@@ -6,7 +6,7 @@
 from typing import Annotated, Literal, Optional, Union, get_origin
 
 import autograd.numpy as anp
-from autograd.builtins import dict as TracedDict
+from autograd.builtins import dict as _AutogradTracedDict
 from autograd.extend import Box, defvjp, primitive
 from pydantic import BeforeValidator, PlainSerializer, PositiveFloat, TypeAdapter
 
@@ -16,6 +16,30 @@
 
 from .utils import get_static, hasbox
 
+
+class TracedDict(_AutogradTracedDict):
+    """Custom TracedDict that preserves tuple keys instead of converting them to lists."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize TracedDict while preserving tuple keys."""
+        if args and isinstance(args[0], dict):
+            # Convert any list keys back to tuples
+            fixed_dict = {}
+            for key, value in args[0].items():
+                if isinstance(key, list):
+                    key = tuple(key)
+                fixed_dict[key] = value
+            super().__init__(fixed_dict, **kwargs)
+        else:
+            super().__init__(*args, **kwargs)
+
+    def __setitem__(self, key, value):
+        """Ensure keys remain as tuples when setting items."""
+        if isinstance(key, list):
+            key = tuple(key)
+        super().__setitem__(key, value)
+
+
 # add schema to the Box
 _add_schema(Box, title="AutogradBox", field_type_str="autograd.tracer.Box")
 
@@ -114,6 +138,7 @@ def _validate_box_or_container(v):
     "TracedArrayLike",
     "TracedComplex",
     "TracedCoordinate",
+    "TracedDict",
     "TracedFloat",
     "TracedPoleAndResidue",
     "TracedPolesAndResidues",

tidy3d/components/base.py

@@ -14,7 +14,7 @@
 from functools import total_ordering, wraps
 from math import ceil
 from pathlib import Path
-from typing import Any, Callable, Literal, Optional, TypeVar, Union
+from typing import Any, Callable, Literal, Optional, TypeVar, Union, get_args, get_origin
 
 import h5py
 import numpy as np
@@ -189,6 +189,131 @@ def _hash_self(self) -> str:
         self.to_hdf5(bf)
         return hashlib.sha256(bf.getvalue()).hexdigest()
 
+    def _preprocess_update_values(self, update: Mapping[str, Any]) -> dict[str, Any]:
+        """Preprocess update values to convert lists to tuples where appropriate.
+
+        This helps avoid Pydantic v2 serialization warnings when using `model_copy()`
+        with list values for tuple fields.
+        """
+        if not update:
+            return {}
+
+        def get_tuple_element_type(annotation) -> Optional[type]:
+            """Get the element type of a tuple annotation if it has one consistent type."""
+            origin = get_origin(annotation)
+            if origin is tuple:
+                args = get_args(annotation)
+                if args:
+                    # Check if it's a homogeneous tuple like tuple[bool, ...] or tuple[str, ...]
+                    if len(args) == 2 and args[1] is ...:
+                        return args[0]
+                    # Check if all elements have the same type
+                    if all(arg == args[0] for arg in args):
+                        return args[0]
+            return None
+
+        def should_convert_to_tuple(annotation) -> tuple[bool, Optional[type]]:
+            """Check if the given annotation represents a tuple type and return element type if any."""
+            origin = get_origin(annotation)
+
+            if origin is tuple:
+                return True, get_tuple_element_type(annotation)
+
+            # Union types containing tuple
+            if origin is Union:
+                args = get_args(annotation)
+                for arg in args:
+                    if get_origin(arg) is tuple:
+                        return True, get_tuple_element_type(arg)
+
+            return False, None
+
+        def convert_value(value: Any, field_info) -> Any:
+            """Convert value based on field type information."""
+            annotation = field_info.annotation
+
+            # Handle list/tuple to tuple conversion with proper element types
+            is_tuple, element_type = should_convert_to_tuple(annotation)
+
+            # Check if value is a numpy array and needs to be converted to tuple
+            try:
+                import numpy as np
+
+                if isinstance(value, np.ndarray) and is_tuple:
+                    # Convert numpy array to list first
+                    value = value.tolist()
+            except ImportError:
+                pass
+
+            # Handle autograd SequenceBox - convert to tuple
+            if (
+                is_tuple
+                and hasattr(value, "__class__")
+                and value.__class__.__name__ == "SequenceBox"
+            ):
+                # SequenceBox is iterable, so convert it to tuple
+                return tuple(value)
+
+            if isinstance(value, (list, tuple)) and is_tuple:
+                # Convert elements based on element type
+                if element_type is bool:
+                    # Convert integers to booleans
+                    value = [bool(item) if isinstance(item, int) else item for item in value]
+                elif element_type is str:
+                    # Ensure all elements are strings
+                    value = [str(item) if not isinstance(item, str) else item for item in value]
+                else:
+                    # Check if it's a numpy array or contains numpy types
+                    try:
+                        import numpy as np
+
+                        if any(isinstance(item, np.generic) for item in value):
+                            # Convert numpy types to Python types
+                            value = [
+                                item.item() if isinstance(item, np.generic) else item
+                                for item in value
+                            ]
+                    except ImportError:
+                        pass
+                return tuple(value)
+
+            # Handle int to bool conversion
+            if annotation is bool and isinstance(value, int):
+                return bool(value)
+
+            # Handle dict to Tidy3dBaseModel conversion
+            if isinstance(value, dict):
+                # Check if the annotation is a Tidy3dBaseModel subclass
+                origin = get_origin(annotation)
+                if origin is None:
+                    # Not a generic type, check if it's a direct subclass
+                    try:
+                        if isinstance(annotation, type) and issubclass(annotation, Tidy3dBaseModel):
+                            return annotation(**value)
+                    except (TypeError, AttributeError):
+                        pass
+                elif origin is Union:
+                    # For Union types, try to convert to the first matching Tidy3dBaseModel type
+                    args = get_args(annotation)
+                    for arg in args:
+                        try:
+                            if isinstance(arg, type) and issubclass(arg, Tidy3dBaseModel):
+                                return arg(**value)
+                        except (TypeError, AttributeError, ValueError):
+                            continue
+
+            return value
+
+        processed = {}
+        for field_name, value in update.items():
+            if field_name in self.model_fields:
+                field_info = self.model_fields[field_name]
+                processed[field_name] = convert_value(value, field_info)
+            else:
+                processed[field_name] = value
+
+        return processed
+
     def copy(
         self, *, deep: bool = True, validate: bool = True, update: Mapping[str, Any] | None = None
     ) -> Self:
@@ -209,6 +334,10 @@ def copy(
             if invalid:
                 raise KeyError(f"'{self.type}' received invalid fields on copy: {invalid}")
 
+        # preprocess update values to convert lists to tuples where appropriate
+        if update:
+            update = self._preprocess_update_values(update)
+
         new_model = self.model_copy(deep=deep, update=update)
 
         if validate:
@@ -275,8 +404,8 @@ def updated_copy(
 
     @staticmethod
     def _core_model_traversal(
-        current_obj: Any, current_path_segments: list[str]
-    ) -> Iterator[tuple[Self, list[str]]]:
+        current_obj: Any, current_path_segments: tuple[str, ...]
+    ) -> Iterator[tuple[Self, tuple[str, ...]]]:
         """
         Recursively traverses a model structure yielding Tidy3dBaseModel instances and their paths.
 
@@ -288,16 +417,16 @@ def _core_model_traversal(
         current_obj : Any
             The current object in the traversal, which can be a :class:`Tidy3dBaseModel`,
             list, tuple, or other type.
-        current_path_segments : list[str]
-            A list of strings representing the path segments from the initial model
+        current_path_segments : tuple[str, ...]
+            A tuple of strings representing the path segments from the initial model
             to the ``current_obj``.
 
         Returns
         -------
-        Iterator[tuple[Self, list[str]]]
+        Iterator[tuple[Self, tuple[str, ...]]]
             An iterator yielding tuples, where the first element is a found :class:`Tidy3dBaseModel` instance
-            and the second is a list of strings representing the path to that instance
-            from the initial object. The path for the top-level model itself will be an empty list.
+            and the second is a tuple of strings representing the path to that instance
+            from the initial object. The path for the top-level model itself will be an empty tuple.
         """
         if isinstance(current_obj, Tidy3dBaseModel):
             yield current_obj, current_path_segments
@@ -311,12 +440,12 @@ def _core_model_traversal(
 
                 field_value = getattr(current_obj, field_name)
                 yield from Tidy3dBaseModel._core_model_traversal(
-                    field_value, [*current_path_segments, field_name]
+                    field_value, (*current_path_segments, field_name)
                 )
         elif isinstance(current_obj, (list, tuple)):
             for index, item in enumerate(current_obj):
                 yield from Tidy3dBaseModel._core_model_traversal(
-                    item, [*current_path_segments, str(index)]
+                    item, (*current_path_segments, str(index))
                 )
 
     def find_paths(self, target_field_name: str, target_field_value: Any = Undefined) -> list[str]:
@@ -357,7 +486,7 @@ def find_paths(self, target_field_name: str, target_field_value: Any = Undefined
         found_paths_set = set()
 
         for sub_model_instance, path_segments_to_sub_model in Tidy3dBaseModel._core_model_traversal(
-            self, []
+            self, ()
         ):
             if target_field_name in sub_model_instance.model_fields:
                 passes_value_filter = True
@@ -415,7 +544,7 @@ def find_submodels(self, target_type: Self) -> list[Self]:
         """
         found_models_dict = {}
 
-        for sub_model_candidate, _ in Tidy3dBaseModel._core_model_traversal(self, []):
+        for sub_model_candidate, _ in Tidy3dBaseModel._core_model_traversal(self, ()):
             if isinstance(sub_model_candidate, target_type):
                 if sub_model_candidate not in found_models_dict:
                     found_models_dict[sub_model_candidate] = True

tidy3d/components/boundary.py

@@ -6,7 +6,13 @@
 from typing import Optional, Union
 
 import numpy as np
-from pydantic import Field, NonNegativeFloat, NonNegativeInt, field_validator, model_validator
+from pydantic import (
+    Field,
+    NonNegativeFloat,
+    NonNegativeInt,
+    field_validator,
+    model_validator,
+)
 
 from tidy3d.compat import Self
 from tidy3d.constants import EPSILON_0, MU_0, PML_SIGMA
@@ -834,6 +840,14 @@ class BoundarySpec(Tidy3dBaseModel):
         "so explicitly setting the boundaries is recommended.",
     )
 
+    @field_validator("x", "y", "z", mode="before")
+    @classmethod
+    def dict_to_boundary(cls, v):
+        """Convert dict representation to Boundary object if needed."""
+        if isinstance(v, dict) and "plus" in v and "minus" in v:
+            return Boundary(**v)
+        return v
+
     def __getitem__(self, field_name: str) -> Boundary:
         """Get the :class:`Boundary` field by name (``boundary_spec[field_name]``).
 

tidy3d/components/source/freq_range.py

@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 import numpy as np
-import pydantic.v1 as pydantic
 from numpy.typing import NDArray
+from pydantic import Field, PositiveFloat
 
 from tidy3d import constants as td_const
 from tidy3d.components.base import Tidy3dBaseModel
@@ -35,15 +35,13 @@ class FreqRange(Tidy3dBaseModel):
     >>> source = freq_range.to_gaussian_pulse()
     """
 
-    freq0: pydantic.PositiveFloat = pydantic.Field(
-        ...,
+    freq0: PositiveFloat = Field(
         title="Central frequency",
         description="Real-valued positive central frequency.",
         units="Hz",
     )
 
-    fwidth: pydantic.PositiveFloat = pydantic.Field(
-        ...,
+    fwidth: PositiveFloat = Field(
         title="Frequency bandwidth",
         description="Real-valued positive width of the frequency range (bandwidth).",
         units="Hz",