fix linting errors

Author: Alexboiboi

docs/examples/soft_magnets.md

@@ -21,7 +21,7 @@ kernelspec:
 This code demonstrates demagnetization calculations for a hard and a soft cuboid
 magnet using the Magpylib library. Demagnetization is applied using varying
 numbers of cells for the mesh and compared to the computed magnetic fields from
-Magpylib withoug demagnetization and with FEM analysis data obtained from an
+Magpylib without demagnetization and with FEM analysis data obtained from an
 external dataset.
 
 +++ {"user_expressions": []}

src/magpylib_material_response/data/__init__.py

@@ -11,9 +11,10 @@ def get_dataset(name):
     from pathlib import Path
 
     name = Path(name).with_suffix("").with_suffix(".json")
-    with importlib.resources.path(
-        "magpylib_material_response.package_data", "datasets"
-    ) as resources_path:
-        with open(resources_path / name) as fp:
-            sim = json.load(fp)
-    return sim
+    with (
+        importlib.resources.path(
+            "magpylib_material_response.package_data", "datasets"
+        ) as resources_path,
+        (resources_path / name).open() as fp,
+    ):
+        return json.load(fp)

src/magpylib_material_response/demag.py

@@ -1,7 +1,5 @@
 """demag_functions"""
 
-# +
-# pylint: disable=invalid-name, redefined-outer-name, protected-access
 from __future__ import annotations
 
 import sys
@@ -18,24 +16,24 @@
 
 config = {
     "handlers": [
-        dict(
-            sink=sys.stdout,
-            colorize=True,
-            format=(
+        {
+            "sink": sys.stdout,
+            "colorize": True,
+            "format": (
                 "<magenta>{time:YYYY-MM-DD at HH:mm:ss}</magenta>"
                 " | <level>{level:^8}</level>"
                 " | <cyan>{function}</cyan>"
                 " | <yellow>{extra}</yellow> {level.icon:<2} {message}"
             ),
-        ),
+        },
     ],
 }
 logger.configure(**config)
 
 
 def get_susceptibilities(sources, susceptibility):
     """Return a list of length (len(sources)) with susceptibility values
-    Priority is given at the source level, hovever if value is not found, it is searched
+    Priority is given at the source level, however if value is not found, it is searched
     up the parent tree, if available. Raises an error if no value is found when reached
     the top level of the tree."""
     n = len(sources)
@@ -47,31 +45,31 @@ def get_susceptibilities(sources, susceptibility):
             susceptibility = getattr(src, "susceptibility", None)
             if susceptibility is None:
                 if src.parent is None:
-                    raise ValueError(
-                        "No susceptibility defined in any parent collection"
-                    )
+                    msg = "No susceptibility defined in any parent collection"
+                    raise ValueError(msg)
                 susis.extend(get_susceptibilities(src.parent))
             elif not hasattr(susceptibility, "__len__"):
                 susis.append((susceptibility, susceptibility, susceptibility))
             elif len(susceptibility) == 3:
                 susis.append(susceptibility)
             else:
-                raise ValueError("susceptibility is not scalar or array fo length 3")
+                msg = "susceptibility is not scalar or array of length 3"
+                raise ValueError(msg)
     # susceptibilities as input to demag function
     elif np.isscalar(susceptibility):
         susis = np.ones((n, 3)) * susceptibility
     elif len(susceptibility) == 3:
         susis = np.tile(susceptibility, (n, 1))
         if n == 3:
-            raise ValueError(
+            msg = (
                 "Apply_demag input susceptibility is ambiguous - either scalar list or vector single entry. "
                 "Please choose different means of input or change the number of cells in the Collection."
             )
+            raise ValueError(msg)
     else:
         if len(susceptibility) != n:
-            raise ValueError(
-                "Apply_demag input susceptibility must be scalar, 3-vector, or same length as input Collection."
-            )
+            msg = "Apply_demag input susceptibility must be scalar, 3-vector, or same length as input Collection."
+            raise ValueError(msg)
         susis = np.array(susceptibility)
         if susis.ndim == 1:
             susis = np.repeat(susis, 3).reshape(n, 3)
@@ -82,7 +80,7 @@ def get_susceptibilities(sources, susceptibility):
 
 def get_H_ext(*sources, H_ext=None):
     """Return a list of length (len(sources)) with H_ext values
-    Priority is given at the source level, hovever if value is not found, it is searched up the
+    Priority is given at the source level, however if value is not found, it is searched up the
     the parent tree, if available. Sets H_ext to zero if no value is found when reached the top
     level of the tree"""
     H_exts = []
@@ -120,7 +118,7 @@ def demag_tensor(
         calculated only once and copied to duplicates.
 
     split: int
-        Number of times the sources list is splitted before getH calculation ind demag
+        Number of times the sources list is split before getH calculation ind demag
         tensor calculation
 
     min_log_time:
@@ -141,7 +139,8 @@ def demag_tensor(
     nof_src = len(src_list)
 
     if pairs_matching and split != 1:
-        raise ValueError("Pairs matching does not support splitting")
+        msg = "Pairs matching does not support splitting"
+        raise ValueError(msg)
     if max_dist != 0:
         mask_inds, getH_params, pos0, rot0 = filter_distance(
             src_list, max_dist, return_params=False, return_base_geo=True
@@ -192,9 +191,7 @@ def demag_tensor(
             H_point.append(H_unit_pol)  # shape (n_cells, n_pos, 3_xyz)
 
     # shape (3_unit_pol, n_cells, n_pos, 3_xyz)
-    T = np.array(H_point).reshape((3, nof_src, nof_src, 3))
-
-    return T
+    return np.array(H_point).reshape((3, nof_src, nof_src, 3))
 
 
 def filter_distance(
@@ -208,9 +205,8 @@ def filter_distance(
     with timelog("Distance filter", min_log_time=min_log_time):
         all_cuboids = all(isinstance(src, Cuboid) for src in src_list)
         if not all_cuboids:
-            raise ValueError(
-                "filter_distance only implemented if all sources are Cuboids"
-            )
+            msg = "filter_distance only implemented if all sources are Cuboids"
+            raise ValueError(msg)
         pos0 = np.array([getattr(src, "barycenter", src.position) for src in src_list])
         rotQ0 = [src.orientation.as_quat() for src in src_list]
         rot0 = R.from_quat(rotQ0)
@@ -222,12 +218,14 @@ def filter_distance(
         maxdim2 = np.concatenate(dim2, axis=1).max(axis=1)
         mask = (dist2 / maxdim2) < max_dist
         if return_params:
-            params = dict(
-                observers=np.tile(pos0, (len(src_list), 1))[mask],
-                position=np.repeat(pos0, len(src_list), axis=0)[mask],
-                orientation=R.from_quat(np.repeat(rotQ0, len(src_list), axis=0))[mask],
-                dimension=np.repeat(dim0, len(src_list), axis=0)[mask],
-            )
+            params = {
+                "observers": np.tile(pos0, (len(src_list), 1))[mask],
+                "position": np.repeat(pos0, len(src_list), axis=0)[mask],
+                "orientation": R.from_quat(np.repeat(rotQ0, len(src_list), axis=0))[
+                    mask
+                ],
+                "dimension": np.repeat(dim0, len(src_list), axis=0)[mask],
+            }
         dsf = sum(mask) / len(mask) * 100
     log_msg = (
         "Interaction pairs left after distance factor filtering: "
@@ -252,9 +250,8 @@ def match_pairs(src_list, min_log_time=1):
     with timelog("Pairs matching", min_log_time=min_log_time):
         all_cuboids = all(isinstance(src, Cuboid) for src in src_list)
         if not all_cuboids:
-            raise ValueError(
-                "Pairs matching only implemented if all sources are Cuboids"
-            )
+            msg = "Pairs matching only implemented if all sources are Cuboids"
+            raise ValueError(msg)
         pos0 = np.array([getattr(src, "barycenter", src.position) for src in src_list])
         rotQ0 = [src.orientation.as_quat() for src in src_list]
         rot0 = R.from_quat(rotQ0)
@@ -283,12 +280,12 @@ def match_pairs(src_list, min_log_time=1):
                 f"<blue>{perc:.2f}%</blue>"
             )
 
-        params = dict(
-            observers=np.tile(pos0, (len(src_list), 1))[unique_inds],
-            position=np.repeat(pos0, len(src_list), axis=0)[unique_inds],
-            orientation=R.from_quat(rotQ2b)[unique_inds],
-            dimension=np.repeat(dim0, len(src_list), axis=0)[unique_inds],
-        )
+        params = {
+            "observers": np.tile(pos0, (len(src_list), 1))[unique_inds],
+            "position": np.repeat(pos0, len(src_list), axis=0)[unique_inds],
+            "orientation": R.from_quat(rotQ2b)[unique_inds],
+            "dimension": np.repeat(dim0, len(src_list), axis=0)[unique_inds],
+        }
     return params, unique_inds, unique_inv_inds, pos0, rot0
 
 
@@ -331,7 +328,7 @@ def apply_demag(
         `pairs_matching` or `split` and applies only cuboid cells.
 
     split: int
-        Number of times the sources list is splitted before getH calculation ind demag
+        Number of times the sources list is split before getH calculation ind demag
         tensor calculation. This parameter is not compatible with `pairs_matching` or
         `max_dist`.
 
@@ -353,10 +350,11 @@ def apply_demag(
     srcs = collection.sources_all
     src_with_paths = [src for src in srcs if src.position.ndim != 1]
     if src_with_paths:
-        raise ValueError(
+        msg = (
             f"{len(src_with_paths)} objects with paths, found. Demagnetization of "
             "objects with paths is not yet supported"
         )
+        raise ValueError(msg)
     magnets_list = [src for src in srcs if isinstance(src, BaseMagnet)]
     currents_list = [src for src in srcs if isinstance(src, BaseCurrent)]
     others_list = [
@@ -365,16 +363,17 @@ def apply_demag(
         if not isinstance(src, (BaseMagnet, BaseCurrent, magpy.Sensor))
     ]
     if others_list:
-        raise TypeError(
+        msg = (
             "Only Magnet and Current sources supported. "
             "Incompatible objects found: "
             f"{Counter(s.__class__.__name__ for s in others_list)}"
         )
+        raise TypeError(msg)
     n = len(magnets_list)
     counts = Counter(s.__class__.__name__ for s in magnets_list)
     inplace_str = f"""{" (inplace)" if inplace else ""}"""
     lbl = collection.style.label
-    coll_str = str(collection) if not lbl else lbl
+    coll_str = lbl if lbl else str(collection)
     demag_msg = (
         f"Demagnetization{inplace_str} of <blue>{coll_str}</blue>"
         f" with {n} cells - {counts}"
@@ -399,9 +398,8 @@ def apply_demag(
         H_ext = get_H_ext(*magnets_list)
         H_ext = np.array(H_ext)
         if len(H_ext) != n:
-            raise ValueError(
-                "Apply_demag input collection and H_ext must have same length."
-            )
+            msg = "Apply_demag input collection and H_ext must have same length."
+            raise ValueError(msg)
         H_ext = np.reshape(H_ext, (3 * n, 1), order="F")
 
         # set up T (3 pol unit, n cells, n positions, 3 Bxyz)
@@ -442,3 +440,4 @@ def apply_demag(
 
     if not inplace:
         return collection
+    return None

src/magpylib_material_response/meshing.py

@@ -52,10 +52,11 @@ def mesh_Cuboid(cuboid, target_elems, verbose=False, **kwargs):
         Collection of Cuboid cells
     """
     if not isinstance(cuboid, magpy.magnet.Cuboid):
-        raise TypeError(
+        msg = (
             "Object to be meshed must be a Cuboid, "
             f"received instead {cuboid.__class__.__name__!r}"
         )
+        raise TypeError(msg)
     dim0 = cuboid.dimension
     pol0 = cuboid.polarization
 
@@ -128,12 +129,13 @@ def mesh_Cylinder(cylinder, target_elems, verbose=False, **kwargs):
             360,
         )
     else:
-        raise TypeError("Input must be a Cylinder or CylinderSegment")
+        msg = "Input must be a Cylinder or CylinderSegment"
+        raise TypeError(msg)
 
     al = (r2 + r1) * 3.14 * (phi2 - phi1) / 360  # arclen = D*pi*arcratio
     dim = al, r2 - r1, h
     pol0 = cylinder.polarization
-    # "unroll" the cylinder and distribute the target number of elemens along the
+    # "unroll" the cylinder and distribute the target number of elements along the
     # circumference, radius and height.
     if np.isscalar(target_elems):
         nphi, nr, nh = cells_from_dimension(dim, target_elems)
@@ -195,7 +197,7 @@ def mesh_thin_CylinderSegment_with_cuboids(
         CylinderSegment object to be discretized
     target_elems: int or tuple of int,
         If `target_elems` is a  tuple of integers, the cylinder segment is respectively
-        divided over circumference and height, if an integer, divisions are infered to
+        divided over circumference and height, if an integer, divisions are inferred to
         build cuboids with close to squared faces.
     ratio_limit: positive number,
         Sets the r2/(r2-r1) limit to be considered as thin-walled, r1 being the inner
@@ -214,11 +216,12 @@ def mesh_thin_CylinderSegment_with_cuboids(
     r1, r2, h, phi1, phi2 = cyl_seg.dimension
     pol0 = cyl_seg.polarization
     if ratio_limit > r2 / (r2 - r1):
-        raise ValueError(
+        msg = (
             "This meshing function is intended for thin-walled CylinderSegment objects"
             f" of radii-ratio r2/(r2-r1)>{ratio_limit}, r1 being the inner radius."
             f"\nInstead r2/(r2-r1)={r2 / (r2 - r1)}"
         )
+        raise ValueError(msg)
     # distribute elements -> targeting thin close-to-square surface cells
     circumf = 2 * np.pi * r1
     if np.isscalar(target_elems):
@@ -279,12 +282,14 @@ def slice_Cuboid(cuboid, shift=0.5, axis="z", **kwargs):
         If the shift value is not between 0 and 1 (exclusive).
     """
     if not isinstance(cuboid, magpy.magnet.Cuboid):
-        raise TypeError(
+        msg = (
             "Object to be sliced must be a Cuboid, "
             f"received instead {cuboid.__class__.__name__!r}"
         )
+        raise TypeError(msg)
     if not 0 < shift < 1:
-        raise ValueError("Shift must be between 0 and 1 (exclusive)")
+        msg = "Shift must be between 0 and 1 (exclusive)"
+        raise ValueError(msg)
     dim0 = cuboid.dimension
     pol0 = cuboid.polarization
     ind = "xyz".index(axis)
@@ -347,7 +352,8 @@ def voxelize(obj, target_elems, strict_inside=True, **kwargs):
         )
         grid = grid[pos_inside_strict_mask]
         if grid.size == 0:
-            raise ValueError("No cuboids left with strict-inside method")
+            msg = "No cuboids left with strict-inside method"
+            raise ValueError(msg)
 
     cells = []
     for pos in grid:
@@ -399,7 +405,7 @@ def mesh_all(
         If there are incompatible objects found.
     """
     supported = (magpy.magnet.Cuboid, magpy.magnet.Cylinder)
-    allowed = supported + (BaseCurrent,)
+    allowed = (*supported, BaseCurrent)
     if not inplace:
         obj = obj.copy(**kwargs)
     children = [obj]
@@ -415,18 +421,19 @@ def mesh_all(
     else:
         target_elems_by_child = [max(min_elems, target_elems)] * len(supported_objs)
     if incompatible_objs:
-        raise TypeError(
+        msg = (
             "Incompatible objects found: "
             f"{Counter(s.__class__.__name__ for s in incompatible_objs)}"
             f"\nSupported: {[s.__name__ for s in supported]}."
         )
-    for child, target_elems in zip(supported_objs, target_elems_by_child):
+        raise TypeError(msg)
+    for child, targ_elems in zip(supported_objs, target_elems_by_child):
         parent = child.parent
         kw = kwargs if parent is None else {}
         if isinstance(child, magpy.magnet.Cuboid):
-            child_meshed = mesh_Cuboid(child, target_elems, **kw)
+            child_meshed = mesh_Cuboid(child, targ_elems, **kw)
         elif isinstance(child, magpy.magnet.Cylinder):
-            child_meshed = mesh_Cylinder(child, target_elems, **kw)
+            child_meshed = mesh_Cylinder(child, targ_elems, **kw)
         child.parent = None
         if parent is not None:
             parent.add(child_meshed)