Lint data/ dirs

Author: yaugenst-flex

tidy3d/components/base_sim/data/monitor_data.py

@@ -6,8 +6,8 @@
 
 import pydantic.v1 as pd
 
-from ...data.dataset import Dataset
-from ..monitor import AbstractMonitor
+from tidy3d.components.base_sim.monitor import AbstractMonitor
+from tidy3d.components.data.dataset import Dataset
 
 
 class AbstractMonitorData(Dataset, ABC):

tidy3d/components/base_sim/data/sim_data.py

@@ -3,17 +3,18 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import Dict, Tuple, Union
+from typing import Union
 
 import numpy as np
 import pydantic.v1 as pd
 import xarray as xr
 
-from ....exceptions import DataError, Tidy3dKeyError, ValidationError
-from ...base import Tidy3dBaseModel, skip_if_fields_missing
-from ...data.utils import UnstructuredGridDatasetType
-from ...types import FieldVal
-from ..simulation import AbstractSimulation
+from tidy3d.components.base import Tidy3dBaseModel, skip_if_fields_missing
+from tidy3d.components.base_sim.simulation import AbstractSimulation
+from tidy3d.components.data.utils import UnstructuredGridDatasetType
+from tidy3d.components.types import FieldVal
+from tidy3d.exceptions import DataError, Tidy3dKeyError, ValidationError
+
 from .monitor_data import AbstractMonitorData
 
 
@@ -28,7 +29,7 @@ class AbstractSimulationData(Tidy3dBaseModel, ABC):
         description="Original :class:`AbstractSimulation` associated with the data.",
     )
 
-    data: Tuple[AbstractMonitorData, ...] = pd.Field(
+    data: tuple[AbstractMonitorData, ...] = pd.Field(
         ...,
         title="Monitor Data",
         description="List of :class:`AbstractMonitorData` instances "
@@ -47,7 +48,7 @@ def __getitem__(self, monitor_name: str) -> AbstractMonitorData:
         return monitor_data.symmetry_expanded_copy
 
     @property
-    def monitor_data(self) -> Dict[str, AbstractMonitorData]:
+    def monitor_data(self) -> dict[str, AbstractMonitorData]:
         """Dictionary mapping monitor name to its associated :class:`AbstractMonitorData`."""
         return {monitor_data.monitor.name: monitor_data for monitor_data in self.data}
 

tidy3d/components/data/data_array.py

@@ -3,7 +3,8 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import Any, Dict, List, Mapping, Union
+from collections.abc import Mapping
+from typing import Any, Optional, Union
 
 import autograd.numpy as anp
 import h5py
@@ -17,19 +18,19 @@
 from xarray.core.utils import OrderedSet, either_dict_or_kwargs
 from xarray.core.variable import as_variable
 
-from ...compat import alignment
-from ...constants import (
+from tidy3d.compat import alignment
+from tidy3d.components.autograd import TidyArrayBox, get_static, interpn, is_tidy_box
+from tidy3d.components.geometry.bound_ops import bounds_contains
+from tidy3d.components.types import Axis, Bound
+from tidy3d.constants import (
     HERTZ,
     MICROMETER,
     PICOSECOND_PER_NANOMETER_PER_KILOMETER,
     RADIAN,
     SECOND,
     WATT,
 )
-from ...exceptions import DataError, FileError
-from ..autograd import TidyArrayBox, get_static, interpn, is_tidy_box
-from ..geometry.bound_ops import bounds_contains
-from ..types import Axis, Bound
+from tidy3d.exceptions import DataError, FileError
 
 # maps the dimension names to their attributes
 DIM_ATTRS = {
@@ -69,7 +70,7 @@ class DataArray(xr.DataArray):
     # stores an ordered tuple of strings corresponding to the data dimensions
     _dims = ()
     # stores a dictionary of attributes corresponding to the data values
-    _data_attrs: Dict[str, str] = {}
+    _data_attrs: dict[str, str] = {}
 
     def __init__(self, data, *args, **kwargs):
         # if data is a vanilla autograd box, convert to our box
@@ -118,7 +119,7 @@ def assign_data_attrs(cls, val):
             val.attrs[attr_name] = attr
         return val
 
-    def _interp_validator(self, field_name: str = None) -> None:
+    def _interp_validator(self, field_name: Optional[str] = None) -> None:
         """Ensure the data can be interpolated or selected by checking for duplicate coordinates.
 
         NOTE
@@ -152,17 +153,17 @@ def assign_coord_attrs(cls, val):
     def __modify_schema__(cls, field_schema):
         """Sets the schema of DataArray object."""
 
-        schema = dict(
-            title="DataArray",
-            type="xr.DataArray",
-            properties=dict(
-                _dims=dict(
-                    title="_dims",
-                    type="Tuple[str, ...]",
-                ),
-            ),
-            required=["_dims"],
-        )
+        schema = {
+            "title": "DataArray",
+            "type": "xr.DataArray",
+            "properties": {
+                "_dims": {
+                    "title": "_dims",
+                    "type": "Tuple[str, ...]",
+                },
+            },
+            "required": ["_dims"],
+        }
         field_schema.update(schema)
 
     @classmethod
@@ -261,7 +262,7 @@ def __hash__(self) -> int:
         token_str = dask.base.tokenize(self)
         return hash(token_str)
 
-    def multiply_at(self, value: complex, coord_name: str, indices: List[int]) -> Self:
+    def multiply_at(self, value: complex, coord_name: str, indices: list[int]) -> Self:
         """Multiply self by value at indices."""
         if isbox(self.data) or isbox(value):
             return self._ag_multiply_at(value, coord_name, indices)
@@ -270,7 +271,7 @@ def multiply_at(self, value: complex, coord_name: str, indices: List[int]) -> Se
         self_mult[{coord_name: indices}] *= value
         return self_mult
 
-    def _ag_multiply_at(self, value: complex, coord_name: str, indices: List[int]) -> Self:
+    def _ag_multiply_at(self, value: complex, coord_name: str, indices: list[int]) -> Self:
         """Autograd multiply_at override when tracing."""
         key = {coord_name: indices}
         _, index_tuple, _ = self.variable._broadcast_indexes(key)

tidy3d/components/data/dataset.py

@@ -3,17 +3,18 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, Optional, Union, get_args
+from typing import Any, Callable, Optional, Union, get_args
 
 import numpy as np
 import pydantic.v1 as pd
 import xarray as xr
 
-from ...constants import C_0, PICOSECOND_PER_NANOMETER_PER_KILOMETER, UnitScaling
-from ...exceptions import DataError
-from ...log import log
-from ..base import Tidy3dBaseModel
-from ..types import Axis, xyz
+from tidy3d.components.base import Tidy3dBaseModel
+from tidy3d.components.types import Axis, xyz
+from tidy3d.constants import C_0, PICOSECOND_PER_NANOMETER_PER_KILOMETER, UnitScaling
+from tidy3d.exceptions import DataError
+from tidy3d.log import log
+
 from .data_array import (
     DataArray,
     EMEScalarFieldDataArray,
@@ -44,7 +45,7 @@ class AbstractFieldDataset(Dataset, ABC):
 
     @property
     @abstractmethod
-    def field_components(self) -> Dict[str, DataArray]:
+    def field_components(self) -> dict[str, DataArray]:
         """Maps the field components to their associated data."""
 
     def apply_phase(self, phase: float) -> AbstractFieldDataset:
@@ -60,15 +61,15 @@ def apply_phase(self, phase: float) -> AbstractFieldDataset:
 
     @property
     @abstractmethod
-    def grid_locations(self) -> Dict[str, str]:
+    def grid_locations(self) -> dict[str, str]:
         """Maps field components to the string key of their grid locations on the yee lattice."""
 
     @property
     @abstractmethod
-    def symmetry_eigenvalues(self) -> Dict[str, Callable[[Axis], float]]:
+    def symmetry_eigenvalues(self) -> dict[str, Callable[[Axis], float]]:
         """Maps field components to their (positive) symmetry eigenvalues."""
 
-    def package_colocate_results(self, centered_fields: Dict[str, ScalarFieldDataArray]) -> Any:
+    def package_colocate_results(self, centered_fields: dict[str, ScalarFieldDataArray]) -> Any:
         """How to package the dictionary of fields computed via self.colocate()."""
         return xr.Dataset(centered_fields)
 
@@ -182,7 +183,7 @@ class ElectromagneticFieldDataset(AbstractFieldDataset, ABC):
     )
 
     @property
-    def field_components(self) -> Dict[str, DataArray]:
+    def field_components(self) -> dict[str, DataArray]:
         """Maps the field components to their associated data."""
         fields = {
             "Ex": self.Ex,
@@ -195,22 +196,22 @@ def field_components(self) -> Dict[str, DataArray]:
         return {field_name: field for field_name, field in fields.items() if field is not None}
 
     @property
-    def grid_locations(self) -> Dict[str, str]:
+    def grid_locations(self) -> dict[str, str]:
         """Maps field components to the string key of their grid locations on the yee lattice."""
-        return dict(Ex="Ex", Ey="Ey", Ez="Ez", Hx="Hx", Hy="Hy", Hz="Hz")
+        return {"Ex": "Ex", "Ey": "Ey", "Ez": "Ez", "Hx": "Hx", "Hy": "Hy", "Hz": "Hz"}
 
     @property
-    def symmetry_eigenvalues(self) -> Dict[str, Callable[[Axis], float]]:
+    def symmetry_eigenvalues(self) -> dict[str, Callable[[Axis], float]]:
         """Maps field components to their (positive) symmetry eigenvalues."""
 
-        return dict(
-            Ex=lambda dim: -1 if (dim == 0) else +1,
-            Ey=lambda dim: -1 if (dim == 1) else +1,
-            Ez=lambda dim: -1 if (dim == 2) else +1,
-            Hx=lambda dim: +1 if (dim == 0) else -1,
-            Hy=lambda dim: +1 if (dim == 1) else -1,
-            Hz=lambda dim: +1 if (dim == 2) else -1,
-        )
+        return {
+            "Ex": lambda dim: -1 if (dim == 0) else +1,
+            "Ey": lambda dim: -1 if (dim == 1) else +1,
+            "Ez": lambda dim: -1 if (dim == 2) else +1,
+            "Hx": lambda dim: +1 if (dim == 0) else -1,
+            "Hy": lambda dim: +1 if (dim == 1) else -1,
+            "Hz": lambda dim: +1 if (dim == 2) else -1,
+        }
 
 
 class FieldDataset(ElectromagneticFieldDataset):
@@ -422,7 +423,7 @@ class AuxFieldDataset(AbstractFieldDataset, ABC):
     )
 
     @property
-    def field_components(self) -> Dict[str, DataArray]:
+    def field_components(self) -> dict[str, DataArray]:
         """Maps the field components to their associated data."""
         fields = {
             "Nfx": self.Nfx,
@@ -432,19 +433,19 @@ def field_components(self) -> Dict[str, DataArray]:
         return {field_name: field for field_name, field in fields.items() if field is not None}
 
     @property
-    def grid_locations(self) -> Dict[str, str]:
+    def grid_locations(self) -> dict[str, str]:
         """Maps field components to the string key of their grid locations on the yee lattice."""
-        return dict(Nfx="Ex", Nfy="Ey", Nfz="Ez")
+        return {"Nfx": "Ex", "Nfy": "Ey", "Nfz": "Ez"}
 
     @property
-    def symmetry_eigenvalues(self) -> Dict[str, Callable[[Axis], float]]:
+    def symmetry_eigenvalues(self) -> dict[str, Callable[[Axis], float]]:
         """Maps field components to their (positive) symmetry eigenvalues."""
 
-        return dict(
-            Nfx=lambda dim: +1,
-            Nfy=lambda dim: +1,
-            Nfz=lambda dim: +1,
-        )
+        return {
+            "Nfx": lambda dim: +1,
+            "Nfy": lambda dim: +1,
+            "Nfz": lambda dim: +1,
+        }
 
 
 class AuxFieldTimeDataset(AuxFieldDataset):
@@ -559,7 +560,7 @@ class ModeSolverDataset(ElectromagneticFieldDataset):
     )
 
     @property
-    def field_components(self) -> Dict[str, DataArray]:
+    def field_components(self) -> dict[str, DataArray]:
         """Maps the field components to their associated data."""
         fields = {
             "Ex": self.Ex,
@@ -632,19 +633,19 @@ class PermittivityDataset(AbstractFieldDataset):
     """
 
     @property
-    def field_components(self) -> Dict[str, ScalarFieldDataArray]:
+    def field_components(self) -> dict[str, ScalarFieldDataArray]:
         """Maps the field components to their associated data."""
-        return dict(eps_xx=self.eps_xx, eps_yy=self.eps_yy, eps_zz=self.eps_zz)
+        return {"eps_xx": self.eps_xx, "eps_yy": self.eps_yy, "eps_zz": self.eps_zz}
 
     @property
-    def grid_locations(self) -> Dict[str, str]:
+    def grid_locations(self) -> dict[str, str]:
         """Maps field components to the string key of their grid locations on the yee lattice."""
-        return dict(eps_xx="Ex", eps_yy="Ey", eps_zz="Ez")
+        return {"eps_xx": "Ex", "eps_yy": "Ey", "eps_zz": "Ez"}
 
     @property
-    def symmetry_eigenvalues(self) -> Dict[str, Callable[[Axis], float]]:
+    def symmetry_eigenvalues(self) -> dict[str, Callable[[Axis], float]]:
         """Maps field components to their (positive) symmetry eigenvalues."""
-        return dict(eps_xx=None, eps_yy=None, eps_zz=None)
+        return {"eps_xx": None, "eps_yy": None, "eps_zz": None}
 
     eps_xx: ScalarFieldDataArray = pd.Field(
         ...,