fix: even more rebase changes

Author: mahlau-flex

tests/test_components/test_lumped_element.py

@@ -341,7 +341,7 @@ def test_1d_lumped_element_not_allowed():
     RLC = td.RLCNetwork(resistance=50)
 
     # Attempting to create a 1D lumped element should raise a validation error
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         td.LinearLumpedElement(
             center=[0, 0, 0],
             size=[1, 0, 0],  # 1D element: only x has non-zero size (invalid)
@@ -351,7 +351,7 @@ def test_1d_lumped_element_not_allowed():
         )
 
     # Other 1D configurations should also fail
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         td.LinearLumpedElement(
             center=[0, 0, 0],
             size=[0, 1, 0],  # 1D element: only y has non-zero size (invalid)
@@ -360,7 +360,7 @@ def test_1d_lumped_element_not_allowed():
             name="1D_RLC",
         )
 
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         td.LinearLumpedElement(
             center=[0, 0, 0],
             size=[0, 0, 1],  # 1D element: only z has non-zero size (invalid)

tests/test_components/test_mode.py

@@ -490,21 +490,21 @@ def test_filter_pol_with_default_sort_spec():
     assert ms.filter_pol == "te"
 
     # filter_pol should fail with custom sort_spec
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(pd.ValidationError):
         td.ModeSpec(
             num_modes=3,
             filter_pol="te",
             sort_spec=td.ModeSortSpec(sort_key="k_eff"),
         )
 
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(pd.ValidationError):
         td.ModeSpec(
             num_modes=3,
             filter_pol="te",
             sort_spec=td.ModeSortSpec(filter_key="TE_fraction"),
         )
 
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(pd.ValidationError):
         td.ModeSpec(
             num_modes=3,
             filter_pol="te",

tests/test_plugins/smatrix/test_terminal_component_modeler.py

@@ -576,13 +576,13 @@ def test_validate_port_must_be_planar():
     injection axis can be properly determined for the underlying lumped element.
     """
     # 1D port (two zeros) should fail validation
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         LumpedPort(center=(0, 0, 0), size=(1, 0, 0), voltage_axis=0, impedance=50, name="1D_port")
 
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         LumpedPort(center=(0, 0, 0), size=(0, 1, 0), voltage_axis=1, impedance=50, name="1D_port")
 
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         LumpedPort(center=(0, 0, 0), size=(0, 0, 1), voltage_axis=2, impedance=50, name="1D_port")
 
     # Planar port (one zero) should work fine

tests/test_plugins/test_mode_solver.py

@@ -4,9 +4,9 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
+import pydantic as pd
 import pytest
 import responses
-from pydantic import ValidationError
 
 import tidy3d as td
 import tidy3d.plugins.mode.web as msweb
@@ -336,7 +336,7 @@ def test_mode_solver_validation():
     )
 
     # frequency is too low
-    with pytest.raises(ValidationError):
+    with pytest.raises(pd.ValidationError):
         ms = ModeSolver(
             simulation=simulation,
             plane=PLANE,
@@ -356,7 +356,7 @@ def test_mode_solver_validation():
 
     # num of modes * plane grid points too large
     # 1) number of modes too big
-    with pytest.raises(ValidationError):
+    with pytest.raises(pd.ValidationError):
         ms = ModeSolver(
             simulation=simulation,
             plane=PLANE,
@@ -365,7 +365,7 @@ def test_mode_solver_validation():
             direction="+",
         )
     # 2) number of grid points too big
-    with pytest.raises(ValidationError):
+    with pytest.raises(pd.ValidationError):
         ms = ModeSolver(
             simulation=simulation.updated_copy(grid_spec=td.GridSpec.uniform(dl=0.0001)),
             plane=PLANE,
@@ -1385,13 +1385,13 @@ def test_translated_dot():
 def test_mode_spec_filter_pol_sort_spec_exclusive():
     """Ensure ModeSpec errors when both filter_pol and sort_spec are set."""
     # Using a non-default sort_key triggers the exclusivity check
-    with pytest.raises(pydantic.ValidationError, match="simultaneously"):
+    with pytest.raises(pd.ValidationError, match="simultaneously"):
         _ = td.ModeSpec(num_modes=1, filter_pol="te", sort_spec=td.ModeSortSpec(sort_key="k_eff"))
     # Using a sort_reference also triggers the exclusivity check
-    with pytest.raises(pydantic.ValidationError, match="simultaneously"):
+    with pytest.raises(pd.ValidationError, match="simultaneously"):
         _ = td.ModeSpec(num_modes=1, filter_pol="te", sort_spec=td.ModeSortSpec(sort_reference=1.5))
     # Using a filter_key also triggers the exclusivity check
-    with pytest.raises(pydantic.ValidationError, match="simultaneously"):
+    with pytest.raises(pd.ValidationError, match="simultaneously"):
         _ = td.ModeSpec(
             num_modes=1, filter_pol="te", sort_spec=td.ModeSortSpec(filter_key="TE_fraction")
         )
@@ -1783,13 +1783,13 @@ def test_mode_sort_spec_drop_modes_all_filtered():
 
 
 def test_mode_sort_spec_drop_modes_requires_filter():
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(pd.ValidationError):
         td.ModeSortSpec(keep_modes="filtered")
 
 
 def test_mode_sort_spec_keep_modes_at_most_num_modes():
     sort_spec = td.ModeSortSpec(keep_modes=4)
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(pd.ValidationError):
         _ = td.ModeSpec(num_modes=2, sort_spec=sort_spec)
 
 
@@ -1815,7 +1815,7 @@ def test_mode_sort_spec_fill_fraction_box_filter_drops_modes():
 
 
 def test_mode_sort_spec_fill_fraction_box_requires_bounding_box():
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(pd.ValidationError):
         td.ModeSortSpec(filter_key="fill_fraction_box")
 
 

tidy3d/components/autograd/derivative_utils.py

@@ -248,7 +248,7 @@ def create_interpolators(self, dtype: Optional[np.dtype[Any]] = None) -> dict[st
         coord_cache = {}
 
         def _make_lazy_interpolator_group(
-            field_data_dict: Optional[FieldData],
+            field_data_dict: Optional[FieldDataDict],
             group_key: Optional[str],
             is_field_group: bool = True,
             override_method: Optional[str] = None,
@@ -717,7 +717,7 @@ def _snap_coordinate_outside(
 
             Parameters
             ----------
-            field_components: FieldData
+            field_components: FieldDataDict
                 The field components (i.e - Ex, Ey, Ez, Hx, Hy, Hz) that we would like to sample just
                 outside the PEC surface using nearest interpolation.
 

tidy3d/components/data/monitor_data.py

@@ -15,7 +15,6 @@
 
 from tidy3d.components.base import cached_property
 from tidy3d.components.base_sim.data.monitor_data import AbstractMonitorData
-from tidy3d.components.geometry.base import Box
 from tidy3d.components.grid.grid import Coords, Grid
 from tidy3d.components.medium import Medium, MediumType
 from tidy3d.components.monitor import (
@@ -91,6 +90,7 @@
     from pandas import DataFrame
 
     from tidy3d.compat import Self
+    from tidy3d.components.geometry.base import Box
     from tidy3d.components.mode_spec import ModeSortSpec, ModeSpec
     from tidy3d.components.source.base import Source
     from tidy3d.components.source.current import PointDipole
@@ -2554,7 +2554,9 @@ def sort_modes(
         all_inds = np.arange(num_modes)
 
         # Helper to compute ordered indices within a subset
-        def _order_indices(indices: NDArray, vals_all: DataArray, sort_order) -> NDArray:
+        def _order_indices(
+            indices: NDArray, vals_all: DataArray, sort_order: Literal["ascending", "descending"]
+        ) -> NDArray:
             if indices.size == 0:
                 return indices
             vals = vals_all.isel(mode_index=indices)

tidy3d/components/medium.py

@@ -1315,8 +1315,20 @@ def _interp_axis(
             values = values.real
 
         if sum_over_freqs:
-            return values.sum(axis=-1).reshape(eps_shape)
-        return values.reshape([*eps_shape, values.shape[-1]])
+            vjp_array = values.sum(axis=-1).reshape(eps_shape)
+        else:
+            vjp_array = values.reshape([*eps_shape, values.shape[-1]])
+
+        # match derivative dtype to the underlying dataset
+        target_array = getattr(spatial_data, "values", None)
+        if target_array is None and hasattr(spatial_data, "data"):
+            target_array = spatial_data.data
+        if target_array is not None:
+            target_dtype = np.asarray(target_array).dtype
+            if not np.issubdtype(target_dtype, np.complexfloating):
+                vjp_array = np.real(vjp_array).astype(target_dtype, copy=False)
+
+        return vjp_array
 
 
 """ Dispersionless Medium """

tidy3d/components/mode_spec.py

@@ -4,7 +4,7 @@
 
 from abc import ABC, abstractmethod
 from math import isclose
-from typing import TYPE_CHECKING, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 import numpy as np
 from pydantic import (
@@ -112,7 +112,7 @@ class ModeSortSpec(Tidy3dBaseModel):
         title="Filtering order",
         description="Select whether the first group contains values over or under the reference.",
     )
-    bounding_box: Optional[Box] = pd.Field(
+    bounding_box: Optional[Box] = Field(
         None,
         title="Bounding box",
         description=(
@@ -121,7 +121,7 @@ class ModeSortSpec(Tidy3dBaseModel):
             "still intersect the monitor plane. Required when filtering or sorting with that key."
         ),
     )
-    keep_modes: Union[Literal["all"], Literal["filtered"], pd.PositiveInt] = pd.Field(
+    keep_modes: Union[Literal["all"], Literal["filtered"], PositiveInt] = Field(
         "all",
         title="Keep Modes",
         description=(
@@ -151,19 +151,22 @@ class ModeSortSpec(Tidy3dBaseModel):
         description=_build_sort_order_description(),
     )
 
-    @pd.validator("sort_order", always=True)
-    @skip_if_fields_missing(["sort_key", "sort_reference"])
-    def _set_default_sort_order(cls, val, values):
+    @model_validator(mode="before")
+    @classmethod
+    def _set_default_sort_order(cls, data: dict[str, Any]) -> dict[str, Any]:
         """Set default sort order based on sort_key and sort_reference."""
+        val = data.get("sort_order")
         if val is not None:
-            return val
-        sort_reference = values.get("sort_reference")
+            return data
+        sort_reference = data.get("sort_reference")
         # When sorting by distance to a reference, ascending is natural (closest first)
         if sort_reference is not None:
-            return "ascending"
+            data["sort_order"] = "ascending"
+            return data
         # Otherwise, use the natural default for each key
-        sort_key = values.get("sort_key")
-        return MODE_DATA_KEY_SORT_ORDER.get(sort_key, "ascending")
+        sort_key = data.get("sort_key", "n_eff")
+        data["sort_order"] = MODE_DATA_KEY_SORT_ORDER.get(sort_key, "ascending")
+        return data
 
     # Frequency tracking - applied after sorting and filtering
     track_freq: Optional[TrackFreq] = Field(
@@ -175,23 +178,25 @@ def _set_default_sort_order(cls, val, values):
         "while at other frequencies it can change depending on the mode tracking.",
     )
 
-    @pd.validator("keep_modes", always=True)
-    def _drop_requires_filter(cls, val, values):
-        if val == "filtered" and values.get("filter_key") is None:
+    @model_validator(mode="after")
+    def _drop_requires_filter(self: Self) -> Self:
+        val = self.keep_modes
+        if val == "filtered" and self.filter_key is None:
             raise ValidationError(
                 "ModeSortSpec.keep_modes 'filtered' requires 'filter_key' to be set."
             )
-        return val
+        return self
 
-    @pd.root_validator(skip_on_failure=True)
-    def _bounding_box_required_for_fill_fraction(cls, values):
-        bbox = values.get("bounding_box")
-        keys = (values.get("filter_key"), values.get("sort_key"))
+    @model_validator(mode="before")
+    @classmethod
+    def _bounding_box_required_for_fill_fraction(cls, data: dict[str, Any]) -> dict[str, Any]:
+        bbox = data.get("bounding_box")
+        keys = (data.get("filter_key"), data.get("sort_key"))
         if any(key == "fill_fraction_box" for key in keys) and bbox is None:
             raise ValidationError(
                 "ModeSortSpec.bounding_box must be set when using 'fill_fraction_box'."
             )
-        return values
+        return data
 
     @property
     def has_custom_sort_or_filter(self) -> bool:
@@ -210,7 +215,7 @@ def has_custom_sort_or_filter(self) -> bool:
             self.filter_key is not None
             or self.sort_key != "n_eff"
             or self.sort_reference is not None
-            or self.sort_order != "descending"
+            or (self.sort_order is not None and self.sort_order != "descending")
             or self.keep_modes != "all"
         )
 
@@ -692,11 +697,12 @@ class AbstractModeSpec(Tidy3dBaseModel, ABC):
         "not be ``None``) to ensure consistent mode ordering across frequencies.",
     )
 
-    @pd.validator("sort_spec", always=True)
-    def _keep_modes_at_most_num_modes(cls, val, values):
+    @model_validator(mode="after")
+    def _keep_modes_at_most_num_modes(self: Self) -> Self:
+        val = self.sort_spec
         if val is not None:
             if isinstance(val.keep_modes, int):
-                num_modes = values.get("num_modes")
+                num_modes = self.num_modes
                 if val.keep_modes > num_modes:
                     raise ValidationError(
                         "ModeSortSpec.keep_modes cannot be larger than 'num_modes'. "
@@ -708,7 +714,7 @@ def _keep_modes_at_most_num_modes(cls, val, values):
                         "'keep_modes=\"filtered\"' to keep exactly those modes matching "
                         "the filter, or setting 'keep_modes=\"all\"' to keep all modes."
                     )
-        return val
+        return self
 
     @field_validator("group_index_step", mode="before")
     @classmethod

tidy3d/plugins/smatrix/component_modelers/terminal.py

@@ -213,7 +213,7 @@ class TerminalComponentModeler(AbstractComponentModeler, MicrowaveBaseModel):
         description="The low frequency smoothing parameters for the terminal component simulation.",
     )
 
-    structure_priority_mode: Optional[PriorityMode] = pd.Field(
+    structure_priority_mode: Optional[PriorityMode] = Field(
         "conductor",
         title="Structure Priority Setting",
         description="If not `None`, override the structure priority mode in the simulation. "

tidy3d/plugins/smatrix/ports/rectangular_lumped.py

@@ -104,6 +104,8 @@ def injection_axis(self) -> int:
     @model_validator(mode="after")
     def _voltage_axis_in_plane(self) -> Self:
         """Ensure voltage integration axis is in the port's plane."""
+        if self.size is None:
+            return self
         if self.voltage_axis == self.size.index(0.0):
             raise ValidationError("'voltage_axis' must lie in the port's plane.")
         return self