Fix tests in Windows (#1712)

* Fix missing check in validator
* Avoid instance validators for unions
* Remove `isinstance` checks for MediumType

Signed-off-by: Lucas Heitzmann Gabrielli <lucas@flexcompute.com>
Co-authored-by: daquinteroflex <dario@flexcompute.com>

tidy3d/plugins/waveguide/rectangular_dielectric.py

@@ -211,76 +211,11 @@ class RectangularDielectric(Tidy3dBaseModel):
     )
 
     @pydantic.validator("wavelength", "core_width", "gap", always=True)
-    def _set_array(cls, val):
+    def _set_non_negative_array(cls, val):
         """Ensure values are not negative and convert to numpy arrays."""
-        result = numpy.array(val, ndmin=1)
-        if any(result < 0):
+        val = numpy.array(val, ndmin=1)
+        if any(val < 0):
             raise ValidationError("Values may not be negative.")
-        return result
-
-    @pydantic.validator("box_medium", always=True)
-    @skip_if_fields_missing(["clad_medium"])
-    def _set_box_medium(cls, val, values):
-        """Set BOX medium same as cladding as default value."""
-        if val is None:
-            clad_medium = values["clad_medium"]
-            if isinstance(clad_medium, MediumType):
-                return clad_medium
-            return clad_medium[:1]
-        return val
-
-    @pydantic.validator("clad_thickness", always=True)
-    @skip_if_fields_missing(["clad_medium", "wavelength"])
-    def _set_clad_thickness(cls, val, values):
-        """Set default cladding thickness based on the max wavelength in the cladding medium."""
-        if val is None:
-            wavelength = values["wavelength"]
-            medium = values["clad_medium"]
-            if not isinstance(medium, MediumType):
-                medium = medium[0]
-            n = numpy.array([medium.nk_model(f)[0] for f in C_0 / wavelength])
-            lda = wavelength / n
-            val = EVANESCENT_TAIL * lda.max()
-        elif isinstance(val, float):
-            if val < 0:
-                raise ValidationError("Thickness may not be negative.")
-        else:
-            val = cls._set_array(val)
-        return val
-
-    @pydantic.validator("box_thickness", always=True)
-    @skip_if_fields_missing(["clad_medium", "wavelength"])
-    def _set_box_thickness(cls, val, values):
-        """Set default BOX thickness based on the max wavelength in the BOX medium."""
-        if val is None:
-            wavelength = values["wavelength"]
-            medium = values["box_medium"]
-            if not isinstance(medium, MediumType):
-                medium = medium[0]
-            n = numpy.array([medium.nk_model(f)[0] for f in C_0 / wavelength])
-            lda = wavelength / n
-            val = EVANESCENT_TAIL * lda.max()
-        elif isinstance(val, float):
-            if val < 0:
-                raise ValidationError("Thickness may not be negative.")
-        else:
-            val = cls._set_array(val)
-        return val
-
-    @pydantic.validator("side_margin", always=True)
-    def _set_side_margin(cls, val, values):
-        """Set default side margin based on BOX and cladding thicknesses."""
-        clad_thickness = values.get("clad_thickness")
-        box_thickness = values.get("box_thickness")
-        if clad_thickness is None or box_thickness is None:
-            # Other validators failed already
-            return None
-        if val is None:
-            if not isinstance(clad_thickness, float):
-                clad_thickness = clad_thickness.sum()
-            if not isinstance(box_thickness, float):
-                box_thickness = box_thickness.sum()
-            val = max(clad_thickness, box_thickness)
         return val
 
     @pydantic.validator("gap", always=True)
@@ -294,24 +229,73 @@ def _validate_gaps(cls, val, values):
             raise ValidationError("Number of gaps must be 1 less than number of core widths.")
         return val
 
+    @pydantic.root_validator
+    def _set_box_medium(cls, values):
+        """Set BOX medium same as cladding as default value."""
+        box_medium = values.get("box_medium")
+        if box_medium is None:
+            clad_medium = values.get("clad_medium")
+            if clad_medium is None:
+                return values
+            if isinstance(clad_medium, tuple):
+                clad_medium = clad_medium[0]
+            values["box_medium"] = clad_medium
+        return values
+
+    @pydantic.root_validator
+    def _set_clad_thickness(cls, values):
+        """Set default clad/BOX thickness based on the max wavelength in the medium."""
+        for side in ("clad", "box"):
+            val = values.get(side + "_thickness")
+            if val is None:
+                wavelength = values.get("wavelength")
+                medium = values.get(side + "_medium")
+                if wavelength is None or medium is None:
+                    return values
+                if isinstance(medium, tuple):
+                    medium = medium[0]
+                n = numpy.array([medium.nk_model(f)[0] for f in C_0 / wavelength])
+                lda = wavelength / n
+                values[side + "_thickness"] = EVANESCENT_TAIL * lda.max()
+            elif isinstance(val, float):
+                if val < 0:
+                    raise ValidationError("Thickness may not be negative.")
+            else:
+                values[side + "_thickness"] = cls._set_non_negative_array(val)
+        return values
+
     @pydantic.root_validator
     def _validate_layers(cls, values):
         """Ensure the number of clad media is compatible with the number of layers supplied."""
         for side in ("clad", "box"):
             thickness = values.get(side + "_thickness")
             medium = values.get(side + "_medium")
             if thickness is None or medium is None:
-                # Other validators failed already
-                return None
+                return values
             num_layers = 1 if isinstance(thickness, float) else thickness.size
-            num_media = 1 if isinstance(medium, MediumType) else len(medium)
+            num_media = 1 if not isinstance(medium, tuple) else len(medium)
             if num_layers != num_media:
                 raise ValidationError(
                     f"Number of '{side}_thickness' values ({num_layers}) must be equal to that of "
                     f"'{side}_medium' ({num_media})."
                 )
         return values
 
+    @pydantic.root_validator
+    def _set_side_margin(cls, values):
+        """Set default side margin based on BOX and cladding thicknesses."""
+        clad_thickness = values.get("clad_thickness")
+        box_thickness = values.get("box_thickness")
+        if clad_thickness is None or box_thickness is None:
+            return values
+        if values["side_margin"] is None:
+            if not isinstance(clad_thickness, float):
+                clad_thickness = clad_thickness.sum()
+            if not isinstance(box_thickness, float):
+                box_thickness = box_thickness.sum()
+            values["side_margin"] = max(clad_thickness, box_thickness)
+        return values
+
     @pydantic.root_validator
     def _ensure_consistency(cls, values):
         """Ensure consistency in setting surface/sidewall models and propagation/normal axes."""
@@ -346,14 +330,14 @@ def _ensure_consistency(cls, values):
     @property
     def _clad_medium(self) -> Tuple[MediumType, ...]:
         """Normalize data type to tuple."""
-        if isinstance(self.clad_medium, MediumType):
+        if not isinstance(self.clad_medium, tuple):
             return (self.clad_medium,)
         return self.clad_medium
 
     @property
     def _box_medium(self) -> Tuple[MediumType, ...]:
         """Normalize data type to tuple."""
-        if isinstance(self.box_medium, MediumType):
+        if not isinstance(self.box_medium, tuple):
             return (self.box_medium,)
         return self.box_medium