axisdef

Author: lfarv

pyat/at/lattice/axisdef.py

@@ -1,6 +1,8 @@
 """Helper functions for axis and plane descriptions"""
+
 from __future__ import annotations
 from typing import Optional, Union
+
 # For sys.version_info.minor < 9:
 from typing import Tuple
 
@@ -16,31 +18,31 @@
     ct=dict(index=5, label=r"$\beta c \tau$", unit=" [m]"),
 )
 for xk, xv in [it for it in _axis_def.items()]:
-    xv['code'] = xk
-    _axis_def[xv['index']] = xv
+    xv["code"] = xk
+    _axis_def[xv["index"]] = xv
     _axis_def[xk.upper()] = xv
-_axis_def['delta'] = _axis_def['dp']
-_axis_def['xp'] = _axis_def['px']   # For backward compatibility
-_axis_def['yp'] = _axis_def['py']   # For backward compatibility
-_axis_def['s'] = _axis_def['ct']
-_axis_def['S'] = _axis_def['ct']
-_axis_def[None] = dict(index=slice(None), label="", unit="", code=":")
+_axis_def["delta"] = _axis_def["dp"]
+_axis_def["xp"] = _axis_def["px"]  # For backward compatibility
+_axis_def["yp"] = _axis_def["py"]  # For backward compatibility
+_axis_def["s"] = _axis_def["ct"]
+_axis_def["S"] = _axis_def["ct"]
+_axis_def[None] = dict(index=None, label="", unit="", code=":")
 _axis_def[Ellipsis] = dict(index=Ellipsis, label="", unit="", code="...")
 
 _plane_def = dict(
     x=dict(index=0, label="x", unit=" [m]"),
     y=dict(index=1, label="y", unit=" [m]"),
-    z=dict(index=2, label="z", unit="")
+    z=dict(index=2, label="z", unit=""),
 )
 for xk, xv in [it for it in _plane_def.items()]:
-    xv['code'] = xk
-    _plane_def[xv['index']] = xv
+    xv["code"] = xk
+    _plane_def[xv["index"]] = xv
     _plane_def[xk.upper()] = xv
-_plane_def['h'] = _plane_def['x']
-_plane_def['v'] = _plane_def['y']
-_plane_def['H'] = _plane_def['x']
-_plane_def['V'] = _plane_def['y']
-_plane_def[None] = dict(index=slice(None), label="", unit="", code=":")
+_plane_def["h"] = _plane_def["x"]
+_plane_def["v"] = _plane_def["y"]
+_plane_def["H"] = _plane_def["x"]
+_plane_def["V"] = _plane_def["y"]
+_plane_def[None] = dict(index=None, label="", unit="", code=":")
 _plane_def[Ellipsis] = dict(index=Ellipsis, label="", unit="", code="...")
 
 

pyat/at/lattice/elements.py

@@ -930,9 +930,9 @@ def is_compatible(self, other) -> bool:
         def invrho(dip: Dipole):
             return dip.BendingAngle / dip.Length
 
-        return (super().is_compatible(other) and
-                self.ExitAngle == -other.EntranceAngle and
-                abs(invrho(self) - invrho(other)) <= 1.e-6)
+        return (super().is_compatible(other)
+                and self.ExitAngle == -other.EntranceAngle
+                and abs(invrho(self) - invrho(other)) <= 1.e-6)
 
     def merge(self, other) -> None:
         super().merge(other)

pyat/at/lattice/lattice_object.py

@@ -319,13 +319,13 @@ def insert(self, idx: SupportsIndex, elem: Element, copy_elements=False):
                                  If :py:obj:`True` a deep copy of elem
                                  is used.
         """
-        # noinspection PyUnusedLocal
         # scan the new element to update it
-        elist = list(self._addition_filter([elem],
+        elist = list(self._addition_filter([elem],  # noqa: F841
                      copy_elements=copy_elements))
         super().insert(idx, elem)
 
     def extend(self, elems: Iterable[Element], copy_elements=False):
+        # noinspection PyUnresolvedReferences
         r"""This method adds all the elements of `elems` to the end of the
         lattice. The behavior is the same as for a :py:obj:`list`
 
@@ -347,24 +347,25 @@ def extend(self, elems: Iterable[Element], copy_elements=False):
         super().extend(elems)
 
     def append(self, elem: Element, copy_elements=False):
-        r"""This method overwrites the inherited method
-            :py:meth:`list.append()`,
-            it behavior is changed, it accepts only AT lattice elements
-            :py:obj:`Element` as input argument.
-
-            Equivalents syntaxes:
-            >>> ring.append(elem)
-            >>> ring += [elem]
-
-            Parameters:
-                elem (Element): AT element to be appended to the lattice
-                copy_elements(bool): Default :py:obj:`True`.
-                                     If :py:obj:`True` a deep copy of elem
-                                     is used
+        # noinspection PyUnresolvedReferences
+        r"""This method overwrites the inherited method :py:meth:`list.append()`,
+        its behavior is changed, it accepts only AT lattice elements
+        :py:obj:`Element` as input argument.
+
+        Equivalents syntaxes:
+        >>> ring.append(elem)
+        >>> ring += [elem]
+
+        Parameters:
+            elem (Element): AT element to be appended to the lattice
+            copy_elements(bool): Default :py:obj:`True`.
+                                 If :py:obj:`True` a deep copy of elem
+                                 is used
         """
         self.extend([elem], copy_elements=copy_elements)
 
     def repeat(self, n: int, copy_elements=True):
+        # noinspection SpellCheckingInspection,PyUnresolvedReferences,PyRedeclaration
         r"""This method allows to repeat the lattice `n` times.
         If `n` does not divide `ring.periodicity`, the new ring
         periodicity is set to 1, otherwise  it is et to
@@ -409,6 +410,7 @@ def copy_fun(elem, copy):
 
     def concatenate(self, *lattices: Iterable[Element],
                     copy_elements=False, copy=False):
+        # noinspection PyUnresolvedReferences,SpellCheckingInspection,PyRedeclaration
         """Concatenate several `Iterable[Element]` with the lattice
 
         Equivalents syntaxes:
@@ -442,6 +444,7 @@ def concatenate(self, *lattices: Iterable[Element],
         return lattice if copy else None
 
     def reverse(self, copy=False):
+        # noinspection PyUnresolvedReferences
         r"""Reverse the order of the lattice and swapt the faces
         of elements. Alignment errors are not swapped
 
@@ -520,7 +523,7 @@ def copy(self) -> Lattice:
     def deepcopy(self) -> Lattice:
         """Returns a deep copy of the lattice"""
         return copy.deepcopy(self)
-        
+
     def slice_elements(self, refpts: Refpts, slices: int = 1) -> Lattice:
         """Create a new lattice by slicing the elements at refpts
 
@@ -542,7 +545,7 @@ def slice_generator(_):
                 else:
                     yield el
 
-        return Lattice(slice_generator, iterator=self.attrs_filter)        
+        return Lattice(slice_generator, iterator=self.attrs_filter)
 
     def slice(self, size: Optional[float] = None, slices: Optional[int] = 1) \
             -> Lattice:
@@ -639,8 +642,8 @@ def energy(self) -> float:
     def energy(self, energy: float):
         # Set the Energy attribute of radiating elements
         for elem in self:
-            if (isinstance(elem, (elt.RFCavity, elt.Wiggler)) or
-                    elem.PassMethod.endswith('RadPass')):
+            if (isinstance(elem, (elt.RFCavity, elt.Wiggler))
+                    or elem.PassMethod.endswith('RadPass')):
                 elem.Energy = energy
         # Set the energy attribute of the Lattice
         # Use a numpy scalar to allow division by zero