update pylint, isort and black versions in format.yml (#8506)

Time to bump the linting and formatting eco-system again.

---------

Co-authored-by: Yushao Chen (Jerry) <[email protected]>

Author: andrijapau

doc/releases/changelog-dev.md

@@ -1,5 +1,3 @@
-:orphan:
-
 # Release 0.44.0-dev (development release)
 
 <h3>New features since last release</h3>
@@ -148,6 +146,9 @@
 
 <h3>Internal changes ⚙️</h3>
 
+* Update versions for `pylint`, `isort` and `black` in `format.yml`
+  [(#8506)](https://github.com/PennyLaneAI/pennylane/pull/8506)
+
 * Reclassifies `registers` as a tertiary module for use with tach.
   [(#8513)](https://github.com/PennyLaneAI/pennylane/pull/8513)
 

pennylane/_grad.py

@@ -50,7 +50,7 @@ def _get_grad_prim():
     grad_prim.prim_type = "higher_order"
 
     @grad_prim.def_impl
-    def _(*args, argnums, jaxpr, n_consts, method, h):
+    def _grad_def_impl(*args, argnums, jaxpr, n_consts, method, h):
         if method or h:  # pragma: no cover
             raise ValueError(f"Invalid values '{method=}' and '{h=}' without QJIT.")
         consts = args[:n_consts]
@@ -63,7 +63,7 @@ def func(*inner_args):
 
     # pylint: disable=unused-argument
     @grad_prim.def_abstract_eval
-    def _(*args, argnums, jaxpr, n_consts, method, h):
+    def _grad_abstract_eval(*args, argnums, jaxpr, n_consts, method, h):
         if len(jaxpr.outvars) != 1 or jaxpr.outvars[0].aval.shape != ():
             raise TypeError("Grad only applies to scalar-output functions. Try jacobian.")
         return tuple(args[i + n_consts] for i in argnums)
@@ -90,7 +90,7 @@ def _get_jacobian_prim():
     jacobian_prim.prim_type = "higher_order"
 
     @jacobian_prim.def_impl
-    def _(*args, argnums, jaxpr, n_consts, method, h):
+    def _jacobian_def_impl(*args, argnums, jaxpr, n_consts, method, h):
         if method or h:  # pragma: no cover
             raise ValueError(f"Invalid values '{method=}' and '{h=}' without QJIT.")
         consts = args[:n_consts]
@@ -103,7 +103,7 @@ def func(*inner_args):
 
     # pylint: disable=unused-argument
     @jacobian_prim.def_abstract_eval
-    def _(*args, argnums, jaxpr, n_consts, method, h):
+    def _jacobian_abstract_eval(*args, argnums, jaxpr, n_consts, method, h):
         in_avals = tuple(args[i + n_consts] for i in argnums)
         out_shapes = tuple(outvar.aval.shape for outvar in jaxpr.outvars)
         return [

pennylane/allocation.py

@@ -49,24 +49,28 @@ class AllocateState(StrEnum):
     allocate_prim.multiple_results = True
 
     @allocate_prim.def_impl
-    def _(*, num_wires, state: AllocateState = AllocateState.ZERO, restored=False):
+    def _allocate_primitive_impl(
+        *, num_wires, state: AllocateState = AllocateState.ZERO, restored=False
+    ):
         raise NotImplementedError("jaxpr containing qubit allocation cannot be executed.")
 
     # pylint: disable=unused-argument
     @allocate_prim.def_abstract_eval
-    def _(*, num_wires, state: AllocateState = AllocateState.ZERO, restored=False):
+    def _allocate_primitive_abstract_eval(
+        *, num_wires, state: AllocateState = AllocateState.ZERO, restored=False
+    ):
         return [jax.core.ShapedArray((), dtype=int) for _ in range(num_wires)]
 
     deallocate_prim = QmlPrimitive("deallocate")
     deallocate_prim.multiple_results = True
 
     @deallocate_prim.def_impl
-    def _(*wires):
+    def _deallocate_primitive_impl(*wires):
         raise NotImplementedError("jaxpr containing qubit deallocation cannot be executed.")
 
     # pylint: disable=unused-argument
     @deallocate_prim.def_abstract_eval
-    def _(*wires):
+    def _deallocate_primitive_abstract_eval(*wires):
         return []
 
 

pennylane/capture/base_interpreter.py

@@ -442,7 +442,7 @@ def _(self, x, *dyn_shape, shape, broadcast_dimensions, sharding):
 
 # pylint: disable=unused-argument
 @PlxprInterpreter.register_primitive(jax.lax.iota_p)
-def _(self, *dyn_shape, dimension, dtype, shape, sharding):
+def _iota_primitive(self, *dyn_shape, dimension, dtype, shape, sharding):
     """Handle the iota primitive created by jnp.arange
 
     >>> import jax
@@ -646,7 +646,7 @@ class FlattenedInterpreter(PlxprInterpreter):
 
 
 @FlattenedInterpreter.register_primitive(pjit_p)
-def _(self, *invals, jaxpr, **params):
+def _pjit_primitive(self, *invals, jaxpr, **params):
     if jax.config.jax_dynamic_shapes:
         # just evaluate it so it doesn't throw dynamic shape errors
         return copy(self).eval(jaxpr.jaxpr, jaxpr.consts, *invals)

pennylane/control_flow/for_loop.py

@@ -280,7 +280,9 @@ def _get_for_loop_qfunc_prim():
 
     # pylint: disable=too-many-arguments
     @for_loop_prim.def_impl
-    def _(start, stop, step, *args, jaxpr_body_fn, consts_slice, args_slice, abstract_shapes_slice):
+    def _impl(
+        start, stop, step, *args, jaxpr_body_fn, consts_slice, args_slice, abstract_shapes_slice
+    ):
 
         consts = args[consts_slice]
         init_state = args[args_slice]
@@ -296,7 +298,7 @@ def _(start, stop, step, *args, jaxpr_body_fn, consts_slice, args_slice, abstrac
 
     # pylint: disable=unused-argument
     @for_loop_prim.def_abstract_eval
-    def _(start, stop, step, *args, args_slice, abstract_shapes_slice, **_):
+    def _abstract_eval(start, stop, step, *args, args_slice, abstract_shapes_slice, **_):
         return args[abstract_shapes_slice] + args[args_slice]
 
     return for_loop_prim

pennylane/control_flow/while_loop.py

@@ -233,7 +233,7 @@ def _get_while_loop_qfunc_prim():
     register_custom_staging_rule(while_loop_prim, lambda params: params["jaxpr_body_fn"].outvars)
 
     @while_loop_prim.def_impl
-    def _(
+    def _impl(
         *args,
         jaxpr_body_fn,
         jaxpr_cond_fn,
@@ -253,7 +253,7 @@ def _(
         return fn_res
 
     @while_loop_prim.def_abstract_eval
-    def _(*args, args_slice, **__):
+    def _abstract_eval(*args, args_slice, **__):
         return args[args_slice]
 
     return while_loop_prim

pennylane/data/base/typing_util.py

@@ -77,6 +77,9 @@ def get_type_str(cls: type | str | None) -> str:  # pylint: disable=too-many-ret
 
     Otherwise, returns the fully-qualified class name, including the module.
     """
+    # pylint: disable=unidiomatic-typecheck
+    # Keep this check as it ensures that get_type_str(type(None)) = 'None'
+    # rather than `NoneType`.
     if cls is None or cls is type(None):
         return "None"
 

pennylane/decomposition/collect_resource_ops.py

@@ -35,7 +35,9 @@ def interpret_operation(self, op):
 
 
 @CollectResourceOps.register_primitive(adjoint_transform_prim)
-def _(self, *invals, jaxpr, lazy, n_consts):  # pylint: disable=unused-argument
+def _adjoint_transform_prim(
+    self, *invals, jaxpr, lazy, n_consts
+):  # pylint: disable=unused-argument
     """Collect all operations in the base plxpr and create adjoint resource ops with them."""
     consts = invals[:n_consts]
     args = invals[n_consts:]
@@ -47,7 +49,7 @@ def _(self, *invals, jaxpr, lazy, n_consts):  # pylint: disable=unused-argument
 
 
 @CollectResourceOps.register_primitive(ctrl_transform_prim)
-def _(self, *invals, n_control, jaxpr, n_consts, **params):
+def _ctrl_transform_prim(self, *invals, n_control, jaxpr, n_consts, **params):
     """Collect all operations in the target plxpr and create controlled resource ops with them."""
 
     consts = invals[:n_consts]

pennylane/devices/default_gaussian.py

@@ -517,33 +517,27 @@ def photon_number(cov, mu, params, hbar=2.0):
     return ex, var
 
 
-def homodyne(phi=None):
+def homodyne(phi: float | None = None):
     """Function factory that returns the Homodyne expectation of a one mode state.
 
     Args:
-        phi (float): the default phase space axis to perform the Homodyne measurement
+        phi (Optional[float]): the default phase space axis to perform the Homodyne measurement
 
     Returns:
         function: A function that accepts a single mode means vector, covariance matrix,
         and phase space angle phi, and returns the quadrature expectation
         value and variance.
     """
-    if phi is not None:
 
-        def _homodyne(cov, mu, params, hbar=2.0):
-            """Arbitrary angle homodyne expectation."""
-            # pylint: disable=unused-argument
-            rot = rotation(phi)
-            muphi = rot.T @ mu
-            covphi = rot.T @ cov @ rot
-            return muphi[0], covphi[0, 0]
+    # pylint: disable=unused-argument
+    def _homodyne(cov, mu, params, hbar=2.0):
+        """Calculates the arbitrary angle homodyne expectation."""
 
-        return _homodyne
+        # Use the fixed outer `phi` if it was provided,
+        # otherwise use the dynamic `phi` from the parameters.
+        measurement_phi = phi if phi is not None else params[0]
 
-    def _homodyne(cov, mu, params, hbar=2.0):
-        """Arbitrary angle homodyne expectation."""
-        # pylint: disable=unused-argument
-        rot = rotation(params[0])
+        rot = rotation(measurement_phi)
         muphi = rot.T @ mu
         covphi = rot.T @ cov @ rot
         return muphi[0], covphi[0, 0]

pennylane/devices/qubit/dq_interpreter.py

@@ -231,7 +231,7 @@ def _(self, *invals, reset, postselect):
 
 
 @DefaultQubitInterpreter.register_primitive(adjoint_transform_prim)
-def _(self, *invals, jaxpr, n_consts, lazy=True):
+def _adjoint_transform_prim(self, *invals, jaxpr, n_consts, lazy=True):
     consts = invals[:n_consts]
     args = invals[n_consts:]
     recorder = CollectOpsandMeas()
@@ -251,7 +251,7 @@ def _(self, *invals, jaxpr, n_consts, lazy=True):
 
 # pylint: disable=too-many-arguments
 @DefaultQubitInterpreter.register_primitive(ctrl_transform_prim)
-def _(self, *invals, n_control, jaxpr, control_values, work_wires, n_consts):
+def _ctrl_transform_prim(self, *invals, n_control, jaxpr, control_values, work_wires, n_consts):
     consts = invals[:n_consts]
     control_wires = invals[-n_control:]
     args = invals[n_consts:-n_control]