Repository: PennyLaneAI/pennylane
Pull request #7459 (2025-05-21 17:46:05)

[BugFix] Discrepancy in output values of the example of `qml.pulse.drive`
**Context:** The output of [the code example](https://github.com/PennyLaneAI/pennylane/blob/master/pennylane/pulse/hardware_hamiltonian.py#L105) in the `qml.pulse.hardware_hamiltonian.drive` function should be consistent with the output from the docs.

**Description of the Change:** There was a [long discussion](https://xanaduhq.slack.com/archives/C0743CNS9E3/p1721665038022359) (almost a year ago!) about this issue. The summary is provided by the following message that @Qottmann posted (you can check that the current output in the doc is recovered with the suggested change):

_we just never updated the example after changing the convention that amplitudes are implicitly multiplied by 2 pi (to account for radians). If you run the example with amplitude = lambda p, t: p * jnp.sin(jnp.pi * t) / np.pi / 2. you retrieve the same, old results. So just a matter of updating the docs, though as Tom mentioned this function is not user-facing anymore so low priority_

This also answers the question 'why is this function not appearing in the doc?'

**Benefits:** Corrected documentation.

**Possible Drawbacks:** None.

**Related GitHub Issues:**  #6025 

[sc-69413]


github-actions[bot]: Hello. You may have forgotten to update the changelog!
Please edit [`doc/releases/changelog-dev.md`](/PennyLaneAI/pennylane/blob/master/doc/releases/changelog-dev.md) with:
* A one-to-two sentence description of the change. You may include a small working example for new features.
* A link back to this PR.
* Your name (or GitHub username) in the contributors section.
codecov[bot]: ## [Codecov](https://app.codecov.io/gh/PennyLaneAI/pennylane/pull/7459?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI) Report
All modified and coverable lines are covered by tests :white_check_mark:
> Project coverage is 99.69%. Comparing base [(`9d834af`)](https://app.codecov.io/gh/PennyLaneAI/pennylane/commit/9d834afea4a6ce1002ad611928067db889b48a77?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI) to head [(`5ffbf1b`)](https://app.codecov.io/gh/PennyLaneAI/pennylane/commit/5ffbf1b7d88a6ef184d1850f8482b1eb91ccd63a?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI).

<details><summary>Additional details and impacted files</summary>


```diff
@@           Coverage Diff           @@
##           master    #7459   +/-   ##
=======================================
  Coverage   99.69%   99.69%           
=======================================
  Files         537      537           
  Lines       51203    51203           
=======================================
  Hits        51048    51048           
  Misses        155      155           
```

</details>

[:umbrella: View full report in Codecov by Sentry](https://app.codecov.io/gh/PennyLaneAI/pennylane/pull/7459?dropdown=coverage&src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI).   
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI).

<details><summary> :rocket: New features to boost your workflow: </summary>

- :snowflake: [Test Analytics](https://docs.codecov.com/docs/test-analytics): Detect flaky tests, report on failures, and find test suite problems.
</details>

Patch:
diff --git a/doc/releases/changelog-dev.md b/doc/releases/changelog-dev.md
index bdd7f2939..f06260160 100644
--- a/doc/releases/changelog-dev.md
+++ b/doc/releases/changelog-dev.md
@@ -4,6 +4,32 @@
 
 <h3>New features since last release</h3>
 
+* A new QNode transform called :func:`~.transforms.set_shots` has been added to set or update the number of shots to be performed, overriding shots specified in the device.
+  [(#7337)](https://github.com/PennyLaneAI/pennylane/pull/7337)
+
+  The :func:`~.transforms.set_shots` transform can be used as a decorator:
+
+  ```python
+  @partial(qml.set_shots, shots=2)
+  @qml.qnode(qml.device("default.qubit", wires=1))
+  def circuit():
+      qml.RX(1.23, wires=0)
+      return qml.sample(qml.Z(0))
+  ```
+
+  ```pycon
+  >>> circuit()
+  array([1., -1.])
+  ```
+  
+  Additionally, it can be used in-line to update a circuit's `shots`:
+
+  ```pycon
+  >>> new_circ = qml.set_shots(circuit, shots=(4, 10)) # shot vector
+  >>> new_circ()
+  (array([-1.,  1., -1.,  1.]), array([ 1.,  1.,  1., -1.,  1.,  1., -1., -1.,  1.,  1.]))
+  ```
+
 * A new function called `qml.to_openqasm` has been added, which allows for converting PennyLane circuits to OpenQASM 2.0 programs.
   [(#7393)](https://github.com/PennyLaneAI/pennylane/pull/7393)
 
@@ -486,6 +512,9 @@ Here's a list of deprecations made this release. For a more detailed breakdown o
 
 <h3>Bug fixes 🐛</h3>
 
+* The documentation of `qml.pulse.drive` has been updated and corrected.
+  [(#7459)](https://github.com/PennyLaneAI/pennylane/pull/7459)
+
 * Fixed a bug in `to_openfermion` where identity qubit-to-wires mapping was not obeyed.
   [(#7332)](https://github.com/PennyLaneAI/pennylane/pull/7332)
 
diff --git a/pennylane/__init__.py b/pennylane/__init__.py
index 28da4ed25..92dc22e76 100644
--- a/pennylane/__init__.py
+++ b/pennylane/__init__.py
@@ -130,6 +130,7 @@ from pennylane.transforms import (
     pattern_matching_optimization,
     clifford_t_decomposition,
     add_noise,
+    set_shots,
 )
 from pennylane.ops.functions import (
     dot,
diff --git a/pennylane/_grad.py b/pennylane/_grad.py
index 868c03fce..754622426 100644
--- a/pennylane/_grad.py
+++ b/pennylane/_grad.py
@@ -478,7 +478,6 @@ def jacobian(func, argnum=None, method=None, h=None):
            [ 0.03996468,  0.42472435]], dtype=float64)
 
     """
-    # pylint: disable=no-value-for-parameter
 
     if active_jit := compiler.active_compiler():
         available_eps = compiler.AvailableCompilers.names_entrypoints
diff --git a/pennylane/about.py b/pennylane/about.py
index b6814d2a2..5c5bbf473 100644
--- a/pennylane/about.py
+++ b/pennylane/about.py
@@ -35,9 +35,7 @@ def about():
         plugin_devices = iter_entry_points("pennylane.plugins")
         dist_name = "project_name"
     else:  # pragma: no cover
-        plugin_devices = metadata.entry_points(  # pylint:disable=unexpected-keyword-arg
-            group="pennylane.plugins"
-        )
+        plugin_devices = metadata.entry_points(group="pennylane.plugins")
         dist_name = "name"
     print(check_output([sys.executable, "-m", "pip", "show", "pennylane"]).decode())
     print(f"Platform info:           {platform.platform(aliased=True)}")
diff --git a/pennylane/boolean_fn.py b/pennylane/boolean_fn.py
index a29fcbe35..d818f21c8 100644
--- a/pennylane/boolean_fn.py
+++ b/pennylane/boolean_fn.py
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=protected-access
+
 """
 Contains a utility class ``BooleanFn`` that allows logical composition
 of functions with boolean output.
@@ -19,7 +19,6 @@ of functions with boolean output.
 import functools
 
 
-# pylint: disable=unnecessary-lambda
 class BooleanFn:
     r"""Wrapper for simple callables with Boolean output that can be
     manipulated and combined with bitwise operators.
diff --git a/pennylane/bose/bosonic.py b/pennylane/bose/bosonic.py
index 8b391f3dc..b937c17d0 100644
--- a/pennylane/bose/bosonic.py
+++ b/pennylane/bose/bosonic.py
@@ -17,8 +17,6 @@ from copy import copy
 from pennylane import math
 from pennylane.typing import TensorLike
 
-# pylint: disable= too-many-nested-blocks, too-many-branches, invalid-name
-
 
 class BoseWord(dict):
     r"""Dictionary used to represent a Bose word, a product of bosonic creation and
diff --git a/pennylane/bose/bosonic_mapping.py b/pennylane/bose/bosonic_mapping.py
index be0657b07..e80d10f6e 100644
--- a/pennylane/bose/bosonic_mapping.py
+++ b/pennylane/bose/bosonic_mapping.py
@@ -25,7 +25,6 @@ from pennylane.pauli import PauliSentence, PauliWord
 from .bosonic import BoseSentence, BoseWord
 
 
-# pylint: disable=too-many-branches
 def _get_pauli_op(i, j, qub_id):
     r"""Returns expression to convert qubit-local term ::math::``\ket{x_i}\bra{x_j}``
     to qubit operators as given in :math:`Eq. (6-9)` in `arXiv.1909.12847 <https://arxiv.org/abs/1909.12847>_`.
diff --git a/pennylane/capture/__init__.py b/pennylane/capture/__init__.py
index 011f19de7..716b73b1b 100644
--- a/pennylane/capture/__init__.py
+++ b/pennylane/capture/__init__.py
@@ -182,8 +182,8 @@ from .dynamic_shapes import determine_abstracted_axes, register_custom_staging_r
 AbstractOperator: type
 AbstractMeasurement: type
 qnode_prim: "jax.extend.core.Primitive"
-PlxprInterpreter: type  # pylint: disable=redefined-outer-name
-expand_plxpr_transforms: Callable[[Callable], Callable]  # pylint: disable=redefined-outer-name
+PlxprInterpreter: type
+expand_plxpr_transforms: Callable[[Callable], Callable]
 eval_jaxpr: Callable
 
 
diff --git a/pennylane/capture/autograph/ag_primitives.py b/pennylane/capture/autograph/ag_primitives.py
index 46d5c3661..97a4e5ca7 100644
--- a/pennylane/capture/autograph/ag_primitives.py
+++ b/pennylane/capture/autograph/ag_primitives.py
@@ -203,7 +203,6 @@ def _call_pennylane_for(
     return final_iter_args
 
 
-# pylint: disable=too-many-statements
 def for_stmt(
     iteration_target: Any,
     _extra_test: Union[Callable[[], bool], None],
@@ -245,14 +244,14 @@ def for_stmt(
         enum_start = iteration_target.start_idx
         try:
             iteration_array = jnp.asarray(iteration_target.iteration_target)
-        except Exception as e:  # pylint: disable=bare-except, broad-exception-caught, broad-except
+        except Exception as e:  # pylint: disable=broad-exception-caught,broad-except
             exception_raised = e
     else:
         start, stop, step = 0, len(iteration_target), 1
         enum_start = None
         try:
             iteration_array = jnp.asarray(iteration_target)
-        except Exception as e:  # pylint: disable=bare-except, broad-exception-caught, broad-except
+        except Exception as e:  # pylint: disable=broad-exception-caught,broad-except
             exception_raised = e
 
     if exception_raised:
@@ -275,7 +274,7 @@ def for_stmt(
             enum_start,
             iteration_array,
         )
-    except Exception as e:  # pylint: disable=broad-exception-caught
+    except Exception as e:
         # pylint: disable=import-outside-toplevel
         import textwrap
 
@@ -496,13 +495,17 @@ class PRange:
         return self.py_range.__reversed__()
 
 
-# pylint: disable=too-few-public-methods, super-init-not-called
+# pylint: disable=too-few-public-methods
 class PEnumerate(enumerate):
     """PennyLane enumeration object. Inherits from Python ``enumerate``, but adds storing the
     input iteration_target and start_idx, which are used by the for-loop conversion.
     """
 
     def __init__(self, iterable, start=0):
+
+        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+        # pylint: disable=super-init-not-called
+        # TODO: original enumerate constructor cannot be called as it causes some tests to break
         self.iteration_target = iterable
         self.start_idx = start
 
diff --git a/pennylane/capture/base_interpreter.py b/pennylane/capture/base_interpreter.py
index 2ab42f446..d0c2307d9 100644
--- a/pennylane/capture/base_interpreter.py
+++ b/pennylane/capture/base_interpreter.py
@@ -585,7 +585,7 @@ def handle_while_loop(
     )
 
 
-# pylint: disable=unused-argument, too-many-arguments
+# pylint: disable=too-many-arguments
 @PlxprInterpreter.register_primitive(qnode_prim)
 def handle_qnode(self, *invals, shots, qnode, device, execution_config, qfunc_jaxpr, n_consts):
     """Handle a qnode primitive."""
diff --git a/pennylane/capture/capture_diff.py b/pennylane/capture/capture_diff.py
index 697fae460..2bd128ce4 100644
--- a/pennylane/capture/capture_diff.py
+++ b/pennylane/capture/capture_diff.py
@@ -35,10 +35,9 @@ def _get_grad_prim():
     from .custom_primitives import QmlPrimitive  # pylint: disable=import-outside-toplevel
 
     grad_prim = QmlPrimitive("grad")
-    grad_prim.multiple_results = True  # pylint: disable=attribute-defined-outside-init
+    grad_prim.multiple_results = True
     grad_prim.prim_type = "higher_order"
 
-    # pylint: disable=too-many-arguments
     @grad_prim.def_impl
     def _(*args, argnum, jaxpr, n_consts, method, h):
         if method or h:  # pragma: no cover
@@ -72,10 +71,9 @@ def _get_jacobian_prim():
     from .custom_primitives import QmlPrimitive  # pylint: disable=import-outside-toplevel
 
     jacobian_prim = QmlPrimitive("jacobian")
-    jacobian_prim.multiple_results = True  # pylint: disable=attribute-defined-outside-init
+    jacobian_prim.multiple_results = True
     jacobian_prim.prim_type = "higher_order"
 
-    # pylint: disable=too-many-arguments
     @jacobian_prim.def_impl
     def _(*args, argnum, jaxpr, n_consts, method, h):
         if method or h:  # pragma: no cover
diff --git a/pennylane/capture/capture_meta.py b/pennylane/capture/capture_meta.py
index acbe203be..f46a35018 100644
--- a/pennylane/capture/capture_meta.py
+++ b/pennylane/capture/capture_meta.py
@@ -32,7 +32,6 @@ def _stop_autograph(f):
     return new_f
 
 
-# pylint: disable=no-self-argument, too-few-public-methods
 class CaptureMeta(type):
     """A metatype that dispatches class creation to ``cls._primitve_bind_call`` instead
     of normal class creation.
diff --git a/pennylane/capture/custom_primitives.py b/pennylane/capture/custom_primitives.py
index 8a08e700c..9c34a3a72 100644
--- a/pennylane/capture/custom_primitives.py
+++ b/pennylane/capture/custom_primitives.py
@@ -14,6 +14,10 @@
 """
 This submodule offers custom primitives for the PennyLane capture module.
 """
+
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=abstract-method
+
 from enum import Enum
 from typing import Union
 
@@ -30,7 +34,7 @@ class PrimitiveType(Enum):
     TRANSFORM = "transform"
 
 
-# pylint: disable=too-few-public-methods,abstract-method
+# pylint: disable=too-few-public-methods
 class QmlPrimitive(Primitive):
     """A subclass for JAX's Primitive that differentiates between different
     classes of primitives."""
diff --git a/pennylane/capture/dynamic_shapes.py b/pennylane/capture/dynamic_shapes.py
index 52b21e4a6..091b60b7e 100644
--- a/pennylane/capture/dynamic_shapes.py
+++ b/pennylane/capture/dynamic_shapes.py
@@ -123,7 +123,7 @@ def determine_abstracted_axes(args):
     """
     if not has_jax:  # pragma: no cover
         raise ImportError("jax must be installed to use determine_abstracted_axes")
-    if not jax.config.jax_dynamic_shapes:  # pylint: disable=no-member
+    if not jax.config.jax_dynamic_shapes:
         return None, ()
 
     args, structure = jax.tree_util.tree_flatten(args)
diff --git a/pennylane/circuit_graph.py b/pennylane/circuit_graph.py
index 8909473c2..f0b8dd8bc 100644
--- a/pennylane/circuit_graph.py
+++ b/pennylane/circuit_graph.py
@@ -166,7 +166,7 @@ class CircuitGraph:
         for mp in self.observables_in_order:
             obs = mp.obs or mp
             data, name = ([], "Identity") if obs is mp else (obs.data, str(obs.name))
-            serialization_string += mp.__class__.__name__  # pylint: disable=protected-access
+            serialization_string += mp.__class__.__name__
             serialization_string += delimiter
             serialization_string += name
             for param in data:
diff --git a/pennylane/compiler/compiler.py b/pennylane/compiler/compiler.py
index c31f04522..7bb8b4fdc 100644
--- a/pennylane/compiler/compiler.py
+++ b/pennylane/compiler/compiler.py
@@ -74,7 +74,6 @@ def _refresh_compilers():
     entries = (
         defaultdict(dict, metadata.entry_points())["pennylane.compilers"]
         if version_info[:2] == (3, 9)
-        # pylint:disable=unexpected-keyword-arg
         else metadata.entry_points(group="pennylane.compilers")
     )
 
diff --git a/pennylane/control_flow/while_loop.py b/pennylane/control_flow/while_loop.py
index ef33aa8f0..5dead095a 100644
--- a/pennylane/control_flow/while_loop.py
+++ b/pennylane/control_flow/while_loop.py
@@ -232,7 +232,6 @@ def _get_while_loop_qfunc_prim():
     while_loop_prim.prim_type = "higher_order"
     register_custom_staging_rule(while_loop_prim, lambda params: params["jaxpr_body_fn"].outvars)
 
-    # pylint: disable=too-many-arguments
     @while_loop_prim.def_impl
     def _(
         *args,
diff --git a/pennylane/data/attributes/dictionary.py b/pennylane/data/attributes/dictionary.py
index 2fb45435f..1836bb9b1 100644
--- a/pennylane/data/attributes/dictionary.py
+++ b/pennylane/data/attributes/dictionary.py
@@ -24,7 +24,9 @@ from pennylane.data.base.mapper import MapperMixin
 from pennylane.data.base.typing_util import T
 
 
-class DatasetDict(  # pylint: disable=too-many-ancestors
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=too-many-ancestors
+class DatasetDict(
     Generic[T],
     DatasetAttribute[HDF5Group, Mapping[str, T], Mapping[str, T]],
     MutableMapping[str, T],
diff --git a/pennylane/data/attributes/list.py b/pennylane/data/attributes/list.py
index b721f76a7..1cd016aca 100644
--- a/pennylane/data/attributes/list.py
+++ b/pennylane/data/attributes/list.py
@@ -23,7 +23,9 @@ from pennylane.data.base.mapper import MapperMixin
 from pennylane.data.base.typing_util import T
 
 
-class DatasetList(  # pylint: disable=too-many-ancestors
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=too-many-ancestors
+class DatasetList(
     Generic[T],
     DatasetAttribute[HDF5Group, Sequence[T], Iterable[T]],
     MutableSequence[T],
diff --git a/pennylane/data/base/attribute.py b/pennylane/data/base/attribute.py
index 803d67fb5..e1f2fc573 100644
--- a/pennylane/data/base/attribute.py
+++ b/pennylane/data/base/attribute.py
@@ -372,9 +372,9 @@ class DatasetAttribute(ABC, Generic[HDF5, ValueType, InitValueType]):
     )
     """Maps types to their default DatasetAttribute"""
 
-    def __init_subclass__(  # pylint: disable=arguments-differ
-        cls, *, abstract: bool = False
-    ) -> None:
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=arguments-differ
+    def __init_subclass__(cls, *, abstract: bool = False) -> None:
         if abstract:
             return super().__init_subclass__()
 
diff --git a/pennylane/data/base/dataset.py b/pennylane/data/base/dataset.py
index 6550716c3..be1188f39 100644
--- a/pennylane/data/base/dataset.py
+++ b/pennylane/data/base/dataset.py
@@ -23,7 +23,7 @@ from types import MappingProxyType
 from typing import Any, ClassVar, Generic, Literal, Optional, Type, TypeVar, Union, cast, get_origin
 
 # pylint doesn't think this exists
-from typing_extensions import dataclass_transform  # pylint: disable=no-name-in-module
+from typing_extensions import dataclass_transform
 
 from pennylane.data.base import hdf5
 from pennylane.data.base.attribute import AttributeInfo, DatasetAttribute
@@ -49,7 +49,7 @@ class Field(Generic[T]):
     info: AttributeInfo
 
 
-def field(  # pylint: disable=too-many-arguments, unused-argument
+def field(
     attribute_type: Union[Type[DatasetAttribute[HDF5Any, T, Any]], Literal[UNSET]] = UNSET,
     doc: Optional[str] = None,
     py_type: Optional[Any] = None,
@@ -232,7 +232,7 @@ class Dataset(MapperMixin, _DatasetTransform):
         return self.info.get("data_name", self.__data_name__)
 
     @property
-    def identifiers(self) -> Mapping[str, str]:  # pylint: disable=function-redefined
+    def identifiers(self) -> Mapping[str, str]:
         """Returns this dataset's parameters."""
         return {
             attr_name: getattr(self, attr_name)
@@ -246,7 +246,7 @@ class Dataset(MapperMixin, _DatasetTransform):
         return AttributeInfo(self.bind.attrs)
 
     @property
-    def bind(self) -> HDF5Group:  # pylint: disable=function-redefined
+    def bind(self) -> HDF5Group:
         """Return the HDF5 group that contains this dataset."""
         return self._bind
 
diff --git a/pennylane/data/data_manager/params.py b/pennylane/data/data_manager/params.py
index de5a3be27..607a84c6e 100644
--- a/pennylane/data/data_manager/params.py
+++ b/pennylane/data/data_manager/params.py
@@ -43,7 +43,7 @@ class ParamArg(enum.Enum):
         of its values."""
         return isinstance(val, ParamArg) or (isinstance(val, str) and val in cls.values())
 
-    def __str__(self) -> str:  # pylint: disable=invalid-str-returned
+    def __str__(self) -> str:
         return self.value
 
 
diff --git a/pennylane/debugging/snapshot.py b/pennylane/debugging/snapshot.py
index 4d01cdeaf..23b44b02f 100644
--- a/pennylane/debugging/snapshot.py
+++ b/pennylane/debugging/snapshot.py
@@ -226,7 +226,7 @@ def snapshots_qnode(self, qnode, targs, tkwargs):
     def get_snapshots(*args, **kwargs):
 
         with _SnapshotDebugger(qnode.device) as dbg:
-            # pylint: disable=protected-access
+
             results = qnode(*args, **kwargs)
 
         dbg.snapshots["execution_results"] = results
diff --git a/pennylane/decomposition/decomposition_rule.py b/pennylane/decomposition/decomposition_rule.py
index bf9cec7bb..4a01cccd0 100644
--- a/pennylane/decomposition/decomposition_rule.py
+++ b/pennylane/decomposition/decomposition_rule.py
@@ -255,7 +255,7 @@ def register_resources(
     return _decorator(qfunc) if qfunc else _decorator
 
 
-class DecompositionRule:  # pylint: disable=too-few-public-methods
+class DecompositionRule:
     """Represents a decomposition rule for an operator."""
 
     def __init__(
diff --git a/pennylane/devices/_legacy_device.py b/pennylane/devices/_legacy_device.py
index bca46fa9f..671dd5d16 100644
--- a/pennylane/devices/_legacy_device.py
+++ b/pennylane/devices/_legacy_device.py
@@ -14,7 +14,7 @@
 """
 This module contains the :class:`Device` abstract base class.
 """
-# pylint: disable=too-many-format-args, use-maxsplit-arg, protected-access
+# pylint: disable=use-maxsplit-arg,protected-access
 import abc
 import types
 import warnings
@@ -663,7 +663,7 @@ class Device(abc.ABC, metaclass=_LegacyMeta):
             .QuantumTape: The expanded/decomposed circuit, such that the device
             will natively support all operations.
         """
-        # pylint: disable=protected-access
+
         if max_expansion == 0:
             return circuit
 
@@ -911,7 +911,7 @@ class Device(abc.ABC, metaclass=_LegacyMeta):
         """
 
         # pylint: disable=no-self-use
-        class MockContext:  # pylint: disable=too-few-public-methods
+        class MockContext:
             """Mock class as a default for the with statement in execute()."""
 
             def __enter__(self):
diff --git a/pennylane/devices/_qubit_device.py b/pennylane/devices/_qubit_device.py
index 015bb17c1..5067d7f3d 100644
--- a/pennylane/devices/_qubit_device.py
+++ b/pennylane/devices/_qubit_device.py
@@ -18,7 +18,7 @@ This module contains the :class:`QubitDevice` abstract base class.
 
 # For now, arguments may be different from the signatures provided in Device
 # e.g. instead of expval(self, observable, wires, par) have expval(self, observable)
-# pylint: disable=arguments-differ, abstract-method, no-value-for-parameter,too-many-instance-attributes,too-many-branches, no-member, bad-option-value, arguments-renamed
+# pylint: disable=arguments-differ,too-many-branches,no-member,bad-option-value,arguments-renamed
 # pylint: disable=too-many-arguments
 import abc
 import inspect
@@ -363,7 +363,7 @@ class QubitDevice(Device):
             r = self.statistics(circuit, shot_range=[s1, s2], bin_size=shot_tuple.shots)
 
             # This will likely be required:
-            # if qml.math.get_interface(*r) == "jax":  # pylint: disable=protected-access
+            # if qml.math.get_interface(*r) == "jax":
             #     r = r[0]
 
             if single_measurement:
@@ -1329,7 +1329,7 @@ class QubitDevice(Device):
             array[float]: array of the resulting marginal probabilities.
         """
         dim = 2**self.num_wires
-        batch_size = self._get_batch_size(prob, (dim,), dim)  # pylint: disable=assignment-from-none
+        batch_size = self._get_batch_size(prob, (dim,), dim)
 
         if wires is None:
             # no need to marginalize
@@ -1608,9 +1608,7 @@ class QubitDevice(Device):
             else samples.reshape((bin_size, -1))
         )
 
-    def adjoint_jacobian(
-        self, tape: QuantumScript, starting_state=None, use_device_state=False
-    ):  # pylint: disable=too-many-statements
+    def adjoint_jacobian(self, tape: QuantumScript, starting_state=None, use_device_state=False):
         """Implements the adjoint method outlined in
         `Jones and Gacon <https://arxiv.org/abs/2009.02823>`__ to differentiate an input tape.
 
@@ -1709,7 +1707,7 @@ class QubitDevice(Device):
 
         trainable_params = []
         for k in tape.trainable_params:
-            # pylint: disable=protected-access
+
             mp_or_op = tape[tape.par_info[k]["op_idx"]]
             if isinstance(mp_or_op, MeasurementProcess):
                 warnings.warn(
diff --git a/pennylane/devices/_qutrit_device.py b/pennylane/devices/_qutrit_device.py
index 53e3fdd31..3fe0313b6 100644
--- a/pennylane/devices/_qutrit_device.py
+++ b/pennylane/devices/_qutrit_device.py
@@ -17,7 +17,7 @@ This module contains the :class:`QutritDevice` abstract base class.
 
 # For now, arguments may be different from the signatures provided in QubitDevice to minimize size of pull request
 # e.g. instead of expval(self, observable, wires, par) have expval(self, observable)
-# pylint: disable=arguments-differ, abstract-method, no-value-for-parameter,too-many-instance-attributes,too-many-branches, no-member, bad-option-value, arguments-renamed
+# pylint: disable=bad-option-value,arguments-renamed
 import itertools
 
 import numpy as np
@@ -29,7 +29,7 @@ from pennylane.wires import Wires
 from ._qubit_device import QubitDevice
 
 
-class QutritDevice(QubitDevice):  # pylint: disable=too-many-public-methods
+class QutritDevice(QubitDevice):
     """Abstract base class for PennyLane qutrit devices.
 
     The following abstract method **must** be defined:
@@ -433,7 +433,5 @@ class QutritDevice(QubitDevice):  # pylint: disable=too-many-public-methods
 
     # TODO: Implement function. Currently unimplemented due to lack of decompositions available
     # for existing operations and lack of non-parametrized observables.
-    def adjoint_jacobian(
-        self, tape, starting_state=None, use_device_state=False
-    ):  # pylint: disable=missing-function-docstring
+    def adjoint_jacobian(self, tape, starting_state=None, use_device_state=False):
         raise NotImplementedError
diff --git a/pennylane/devices/default_clifford.py b/pennylane/devices/default_clifford.py
index 773de2fcf..92c57eabe 100644
--- a/pennylane/devices/default_clifford.py
+++ b/pennylane/devices/default_clifford.py
@@ -514,7 +514,6 @@ class DefaultClifford(Device):
         self._rng = np.random.default_rng(self._rng.integers(2**31 - 1))
         return results
 
-    # pylint:disable=no-member,too-many-branches
     def simulate(
         self,
         circuit: qml.tape.QuantumScript,
@@ -673,7 +672,6 @@ class DefaultClifford(Device):
 
         return samples, qml.math.array(coeffs)
 
-    # pylint:disable=protected-access
     def measure_statistical(self, circuit, stim_circuit, seed=None):
         """Given a circuit, compute samples and return the statistical measurement results."""
         # Compute samples via circuits from tableau
@@ -896,7 +894,7 @@ class DefaultClifford(Device):
 
         return entropy / qml.math.log(log_base)
 
-    # pylint: disable=too-many-branches, too-many-statements
+    # pylint: disable=too-many-branches
     def _measure_probability(self, meas, _, **kwargs):
         r"""Measure the probability of each computational basis state.
 
diff --git a/pennylane/devices/default_gaussian.py b/pennylane/devices/default_gaussian.py
index 714d28551..eec994d52 100644
--- a/pennylane/devices/default_gaussian.py
+++ b/pennylane/devices/default_gaussian.py
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=inconsistent-return-statements
+
 """
 The :code:`default.gaussian` device is a simulator for Gaussian continuous-variable
 quantum computations, and can be used as a template for writing PennyLane
@@ -55,7 +55,7 @@ def partitions(s, include_singles=True):
     Returns:
         tuple: returns a nested tuple, containing all partitions of the sequence.
     """
-    # pylint: disable=too-many-branches
+
     if len(s) == 2:
         if include_singles:
             yield (s[0],), (s[1],)
@@ -616,7 +616,7 @@ def fock_expectation(cov, mu, params, hbar=2.0):
     Returns:
         tuple: the Fock state expectation and variance
     """
-    # pylint: disable=unused-argument
+
     ex = fock_prob(cov, mu, params[0], hbar=hbar)
 
     # var[|n><n|] = E[|n><n|^2] -  E[|n><n|]^2 = E[|n><n|] -  E[|n><n|]^2
diff --git a/pennylane/devices/default_mixed.py b/pennylane/devices/default_mixed.py
index ef72afc10..c8947e0b8 100644
--- a/pennylane/devices/default_mixed.py
+++ b/pennylane/devices/default_mixed.py
@@ -18,29 +18,24 @@ It implements some built-in qubit :doc:`operations </introduction/operations>`,
 providing a simple mixed-state simulation of qubit-based quantum circuits.
 
 """
-# isort: skip_file
-# pylint: disable=wrong-import-order, ungrouped-imports
 import logging
-
-import pennylane as qml
-
-from pennylane.math import get_canonical_interface_name
-from pennylane.logging import debug_logger, debug_logger_init
-
-# We deliberately separate the imports to avoid confusion with the legacy device
 import warnings
 from collections.abc import Callable, Sequence
 from dataclasses import replace
 from typing import Optional, Union
 
+import pennylane as qml
 from pennylane.devices.qubit_mixed import simulate
+from pennylane.logging import debug_logger, debug_logger_init
+from pennylane.math import get_canonical_interface_name
 from pennylane.ops.channel import __qubit_channels__ as channels
-from pennylane.transforms.core import TransformProgram
 from pennylane.tape import QuantumScript
+from pennylane.transforms.core import TransformProgram
 from pennylane.typing import Result, ResultBatch
 
 from . import Device
 from .execution_config import ExecutionConfig
+from .modifiers import simulator_tracking, single_tape_support
 from .preprocess import (
     decompose,
     no_sampling,
@@ -49,7 +44,6 @@ from .preprocess import (
     validate_measurements,
     validate_observables,
 )
-from .modifiers import simulator_tracking, single_tape_support
 
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
@@ -208,9 +202,8 @@ class DefaultMixed(Device):
         """The name of the device."""
         return "default.mixed"
 
-    # pylint: disable=too-many-positional-arguments
     @debug_logger_init
-    def __init__(  # pylint: disable=too-many-arguments
+    def __init__(
         self,
         wires=None,
         shots=None,
diff --git a/pennylane/devices/default_qubit.py b/pennylane/devices/default_qubit.py
index dde9e9c11..56ab23eb4 100644
--- a/pennylane/devices/default_qubit.py
+++ b/pennylane/devices/default_qubit.py
@@ -986,7 +986,7 @@ class DefaultQubit(Device):
 
         return tuple(zip(*results))
 
-    # pylint: disable=import-outside-toplevel, unused-argument
+    # pylint: disable=import-outside-toplevel
     @debug_logger
     def eval_jaxpr(
         self, jaxpr: "jax.extend.core.Jaxpr", consts: list[TensorLike], *args, execution_config=None
diff --git a/pennylane/devices/default_qutrit.py b/pennylane/devices/default_qutrit.py
index fef802047..eccbbab5a 100644
--- a/pennylane/devices/default_qutrit.py
+++ b/pennylane/devices/default_qutrit.py
@@ -23,7 +23,7 @@ import logging
 
 import numpy as np
 
-import pennylane as qml  # pylint: disable=unused-import
+import pennylane as qml
 from pennylane.logging import debug_logger, debug_logger_init
 from pennylane.wires import WireError
 
@@ -200,8 +200,10 @@ class DefaultQutrit(QutritDevice):
         wire_map = zip(wires, consecutive_wires)
         return dict(wire_map)
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=arguments-differ
     @debug_logger
-    def apply(self, operations, rotations=None, **kwargs):  # pylint: disable=arguments-differ
+    def apply(self, operations, rotations=None, **kwargs):
         rotations = rotations or []
 
         # apply the circuit operations
@@ -209,7 +211,7 @@ class DefaultQutrit(QutritDevice):
         # Operations are enumerated so that the order of operations can eventually be used
         # for correctly applying basis state / state vector / snapshot operations which will
         # be added later.
-        for i, operation in enumerate(operations):  # pylint: disable=unused-variable
+        for i, operation in enumerate(operations):
             if i > 0 and isinstance(operation, qml.QutritBasisState):
                 raise qml.DeviceError(
                     f"Operation {operation.name} cannot be used after other operations have already been applied "
@@ -273,10 +275,7 @@ class DefaultQutrit(QutritDevice):
         if operation.name in self._apply_ops:  # pylint: disable=no-else-return
             axes = self.wires.indices(wires)
             return self._apply_ops[operation.name](state, axes)
-        elif (
-            isinstance(operation, qml.ops.Adjoint)  # pylint: disable=no-member
-            and operation.base.name in self._apply_ops
-        ):
+        elif isinstance(operation, qml.ops.Adjoint) and operation.base.name in self._apply_ops:
             axes = self.wires.indices(wires)
             return self._apply_ops[operation.base.name](state, axes, inverse=True)
 
diff --git a/pennylane/devices/default_tensor.py b/pennylane/devices/default_tensor.py
index 303ff525a..f95dc60ae 100644
--- a/pennylane/devices/default_tensor.py
+++ b/pennylane/devices/default_tensor.py
@@ -843,7 +843,6 @@ class DefaultTensor(Device):
 
         return float(np.real(exp_val))
 
-    # pylint: disable=unused-argument
     def supports_derivatives(
         self,
         execution_config: Optional[ExecutionConfig] = None,
@@ -897,7 +896,6 @@ class DefaultTensor(Device):
             "The computation of derivatives has yet to be implemented for the default.tensor device."
         )
 
-    # pylint: disable=unused-argument
     def supports_vjp(
         self,
         execution_config: Optional[ExecutionConfig] = None,
diff --git a/pennylane/devices/device_api.py b/pennylane/devices/device_api.py
index ea4bbe3b0..047fba44e 100644
--- a/pennylane/devices/device_api.py
+++ b/pennylane/devices/device_api.py
@@ -14,7 +14,7 @@
 """
 This module contains the Abstract Base Class for the next generation of devices.
 """
-# pylint: disable=comparison-with-callable
+
 import abc
 from collections.abc import Iterable
 from dataclasses import replace
diff --git a/pennylane/devices/device_constructor.py b/pennylane/devices/device_constructor.py
index 74443367e..a95ddacf3 100644
--- a/pennylane/devices/device_constructor.py
+++ b/pennylane/devices/device_constructor.py
@@ -30,7 +30,6 @@ def _get_device_entrypoints():
     entries = (
         metadata.entry_points()["pennylane.plugins"]
         if version_info[:2] == (3, 9)
-        # pylint:disable=unexpected-keyword-arg
         else metadata.entry_points(group="pennylane.plugins")
     )
     return {entry.name: entry for entry in entries}
diff --git a/pennylane/devices/legacy_facade.py b/pennylane/devices/legacy_facade.py
index 76273405a..8572169ea 100644
--- a/pennylane/devices/legacy_facade.py
+++ b/pennylane/devices/legacy_facade.py
@@ -16,7 +16,7 @@ Defines a LegacyDeviceFacade class for converting legacy devices to the
 new interface.
 """
 
-# pylint: disable=not-callable, unused-argument
+# pylint: disable=not-callable
 from contextlib import contextmanager
 from copy import copy, deepcopy
 from dataclasses import replace
@@ -274,7 +274,6 @@ class LegacyDeviceFacade(Device):
             updated_values["grad_on_execution"] = True
         return replace(execution_config, **updated_values)
 
-    # pylint: disable=too-many-return-statements
     def _setup_execution_config(self, execution_config):
         if execution_config.gradient_method == "best":
             tape = qml.tape.QuantumScript([], [])
diff --git a/pennylane/devices/null_qubit.py b/pennylane/devices/null_qubit.py
index c3a59e291..c849edb2d 100644
--- a/pennylane/devices/null_qubit.py
+++ b/pennylane/devices/null_qubit.py
@@ -15,7 +15,7 @@
 The null.qubit device is a no-op device, useful for resource estimation, and for
 benchmarking PennyLane's auxiliary functionality outside direct circuit evaluations.
 """
-# pylint:disable=unused-argument
+
 
 import inspect
 import json
@@ -471,7 +471,8 @@ class NullQubit(Device):
         vjps = tuple(self._vjp(c, _interface(execution_config)) for c in circuits)
         return results, vjps
 
-    # pylint: disable= unused-argument
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=unused-argument
     def eval_jaxpr(
         self, jaxpr: "jax.extend.core.Jaxpr", consts: list, *args, execution_config=None
     ) -> list:
diff --git a/pennylane/devices/qubit/adjoint_jacobian.py b/pennylane/devices/qubit/adjoint_jacobian.py
index a11acabd9..8659433f6 100644
--- a/pennylane/devices/qubit/adjoint_jacobian.py
+++ b/pennylane/devices/qubit/adjoint_jacobian.py
@@ -26,7 +26,7 @@ from .apply_operation import apply_operation
 from .initialize_state import create_initial_state
 from .simulate import get_final_state
 
-# pylint: disable=protected-access, too-many-branches
+# pylint: disable=too-many-branches
 
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
diff --git a/pennylane/devices/qubit/apply_operation.py b/pennylane/devices/qubit/apply_operation.py
index b80c507da..40e5cb8b2 100644
--- a/pennylane/devices/qubit/apply_operation.py
+++ b/pennylane/devices/qubit/apply_operation.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Functions to apply an operation to a state vector."""
-# pylint: disable=unused-argument, too-many-arguments
+# pylint: disable=unused-argument
 
 from functools import singledispatch
 from string import ascii_letters as alphabet
diff --git a/pennylane/devices/qubit/dq_interpreter.py b/pennylane/devices/qubit/dq_interpreter.py
index f6b1d3a37..5755df63e 100644
--- a/pennylane/devices/qubit/dq_interpreter.py
+++ b/pennylane/devices/qubit/dq_interpreter.py
@@ -31,10 +31,10 @@ from .apply_operation import apply_operation
 from .initialize_state import create_initial_state
 from .measure import measure
 from .sampling import measure_with_samples
-from .simulate import _postselection_postprocess  # pylint: disable=protected-access
+from .simulate import _postselection_postprocess
 
 
-# pylint: disable=attribute-defined-outside-init, access-member-before-definition,too-many-instance-attributes
+# pylint: disable=too-many-instance-attributes
 class DefaultQubitInterpreter(FlattenedInterpreter):
     """Implements a class for interpreting plxpr using python simulation tools.
 
@@ -230,7 +230,6 @@ def _(self, *invals, reset, postselect):
     return mcms[mp]
 
 
-# pylint: disable=unused-argument
 @DefaultQubitInterpreter.register_primitive(adjoint_transform_prim)
 def _(self, *invals, jaxpr, n_consts, lazy=True):
     # TODO: requires jaxpr -> list of ops first
diff --git a/pennylane/devices/qubit/sampling.py b/pennylane/devices/qubit/sampling.py
index 527e3296a..d063d0326 100644
--- a/pennylane/devices/qubit/sampling.py
+++ b/pennylane/devices/qubit/sampling.py
@@ -143,7 +143,6 @@ def _get_num_executions_for_sum(obs):
     return len(op_groups)
 
 
-# pylint: disable=no-member
 def get_num_shots_and_executions(tape: qml.tape.QuantumScript) -> tuple[int, int]:
     """Get the total number of qpu executions and shots.
 
diff --git a/pennylane/devices/qubit/simulate.py b/pennylane/devices/qubit/simulate.py
index 6b7ac0805..4702783c9 100644
--- a/pennylane/devices/qubit/simulate.py
+++ b/pennylane/devices/qubit/simulate.py
@@ -15,6 +15,8 @@
 import logging
 
 # pylint: disable=protected-access
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=unused-argument
 from collections import Counter
 from functools import partial, singledispatch
 from typing import Optional
@@ -215,7 +217,6 @@ def get_final_state(circuit, debugger=None, **execution_kwargs):
     return state, is_state_batched
 
 
-# pylint: disable=too-many-arguments
 @debug_logger
 def measure_final_state(circuit, state, is_state_batched, **execution_kwargs) -> Result:
     """
@@ -864,7 +865,7 @@ def combine_measurements(terminal_measurements, results, mcm_samples):
 
 
 @singledispatch
-def combine_measurements_core(original_measurement, measures):  # pylint: disable=unused-argument
+def combine_measurements_core(original_measurement, measures):
     """Returns the combined measurement value of a given type."""
     raise TypeError(
         f"Native mid-circuit measurement mode does not support {type(original_measurement).__name__}"
@@ -872,7 +873,7 @@ def combine_measurements_core(original_measurement, measures):  # pylint: disabl
 
 
 @combine_measurements_core.register
-def _(original_measurement: CountsMP, measures):  # pylint: disable=unused-argument
+def _(original_measurement: CountsMP, measures):
     """The counts are accumulated using a ``Counter`` object."""
     keys = list(measures.keys())
     new_counts = Counter()
@@ -884,7 +885,7 @@ def _(original_measurement: CountsMP, measures):  # pylint: disable=unused-argum
 
 
 @combine_measurements_core.register
-def _(original_measurement: ExpectationMP, measures):  # pylint: disable=unused-argument
+def _(original_measurement: ExpectationMP, measures):
     """The expectation value of two branches is a weighted sum of expectation values."""
     cum_value = 0
     total_counts = 0
@@ -897,7 +898,7 @@ def _(original_measurement: ExpectationMP, measures):  # pylint: disable=unused-
 
 
 @combine_measurements_core.register
-def _(original_measurement: ProbabilityMP, measures):  # pylint: disable=unused-argument
+def _(original_measurement: ProbabilityMP, measures):
     """The combined probability of two branches is a weighted sum of the probabilities. Note the implementation is the same as for ``ExpectationMP``."""
     cum_value = 0
     total_counts = 0
@@ -910,7 +911,7 @@ def _(original_measurement: ProbabilityMP, measures):  # pylint: disable=unused-
 
 
 @combine_measurements_core.register
-def _(original_measurement: SampleMP, measures):  # pylint: disable=unused-argument
+def _(original_measurement: SampleMP, measures):
     """The combined samples of two branches is obtained by concatenating the sample of each branch."""
     new_sample = tuple(
         qml.math.atleast_1d(m[1]) for m in measures.values() if m[0] and not m[1] is tuple()
diff --git a/pennylane/devices/qubit_mixed/apply_operation.py b/pennylane/devices/qubit_mixed/apply_operation.py
index 46ac8c9b9..eda7106c7 100644
--- a/pennylane/devices/qubit_mixed/apply_operation.py
+++ b/pennylane/devices/qubit_mixed/apply_operation.py
@@ -704,7 +704,6 @@ def apply_snapshot(
     return state
 
 
-# pylint: disable=unused-argument
 @apply_operation.register
 def apply_density_matrix(
     op: qml.QubitDensityMatrix,
diff --git a/pennylane/devices/qubit_mixed/initialize_state.py b/pennylane/devices/qubit_mixed/initialize_state.py
index 3a9563aa4..5037f0a6f 100644
--- a/pennylane/devices/qubit_mixed/initialize_state.py
+++ b/pennylane/devices/qubit_mixed/initialize_state.py
@@ -21,7 +21,6 @@ from pennylane import math
 
 
 def create_initial_state(
-    # pylint: disable=unsupported-binary-operation
     wires: Union[qml.wires.Wires, Iterable],
     prep_operation: Union[qml.operation.StatePrepBase, qml.QubitDensityMatrix] = None,
     like: str = None,
diff --git a/pennylane/devices/qubit_mixed/measure.py b/pennylane/devices/qubit_mixed/measure.py
index 4c22d0523..6292e11be 100644
--- a/pennylane/devices/qubit_mixed/measure.py
+++ b/pennylane/devices/qubit_mixed/measure.py
@@ -53,7 +53,7 @@ def _reshape_state_as_matrix(state, num_wires):
     return math.reshape(state, shape)
 
 
-def state_diagonalizing_gates(  # pylint: disable=unused-argument
+def state_diagonalizing_gates(
     measurementprocess: StateMeasurement,
     state: TensorLike,
     is_state_batched: bool = False,
diff --git a/pennylane/devices/qubit_mixed/sampling.py b/pennylane/devices/qubit_mixed/sampling.py
index d1047985e..a390a6548 100644
--- a/pennylane/devices/qubit_mixed/sampling.py
+++ b/pennylane/devices/qubit_mixed/sampling.py
@@ -14,7 +14,7 @@
 """
 Submodule for sampling a qubit mixed state.
 """
-# pylint: disable=too-many-positional-arguments, too-many-arguments
+# pylint: disable=too-many-positional-arguments
 from typing import Callable, Union
 
 import numpy as np
diff --git a/pennylane/devices/qubit_mixed/simulate.py b/pennylane/devices/qubit_mixed/simulate.py
index b9662b502..9f4ef7bf2 100644
--- a/pennylane/devices/qubit_mixed/simulate.py
+++ b/pennylane/devices/qubit_mixed/simulate.py
@@ -14,7 +14,6 @@
 """Simulate a quantum script for a qubit mixed state device."""
 from typing import Optional
 
-# pylint: disable=protected-access
 from numpy.random import default_rng
 
 import pennylane as qml
@@ -93,7 +92,6 @@ def get_final_state(circuit, debugger=None, **execution_kwargs):
     return state, is_state_batched
 
 
-# pylint: disable=too-many-arguments, too-many-positional-arguments, unused-argument
 def measure_final_state(circuit, state, is_state_batched, **execution_kwargs) -> Result:
     """Perform the measurements specified in the circuit on the provided state.
 
@@ -192,7 +190,6 @@ def measure_final_state(circuit, state, is_state_batched, **execution_kwargs) ->
     return results
 
 
-# pylint: disable=too-many-arguments, too-many-positional-arguments
 def simulate(
     circuit: qml.tape.QuantumScript,
     debugger=None,
diff --git a/pennylane/devices/qutrit_mixed/measure.py b/pennylane/devices/qutrit_mixed/measure.py
index 1feefa0ec..2ad934374 100644
--- a/pennylane/devices/qutrit_mixed/measure.py
+++ b/pennylane/devices/qutrit_mixed/measure.py
@@ -234,7 +234,6 @@ def calculate_expval_sum_of_terms(
     )
 
 
-# pylint: disable=too-many-return-statements
 def get_measurement_function(
     measurementprocess: MeasurementProcess,
 ) -> Callable[[MeasurementProcess, TensorLike, bool, list[Callable]], TensorLike]:
diff --git a/pennylane/devices/qutrit_mixed/sampling.py b/pennylane/devices/qutrit_mixed/sampling.py
index f7ad19c97..b6ffd770e 100644
--- a/pennylane/devices/qutrit_mixed/sampling.py
+++ b/pennylane/devices/qutrit_mixed/sampling.py
@@ -242,7 +242,6 @@ def _sample_state_jax(
     Returns:
         ndarray[int]: Sample values of the shape (shots, num_wires)
     """
-    # pylint: disable=import-outside-toplevel
 
     total_indices = get_num_wires(state, is_state_batched)
     state_wires = qml.wires.Wires(range(total_indices))
diff --git a/pennylane/devices/qutrit_mixed/simulate.py b/pennylane/devices/qutrit_mixed/simulate.py
index 0931411b8..f9dd4d9f6 100644
--- a/pennylane/devices/qutrit_mixed/simulate.py
+++ b/pennylane/devices/qutrit_mixed/simulate.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Simulate a quantum script for a qutrit mixed state device."""
-# pylint: disable=protected-access
+
 from numpy.random import default_rng
 
 import pennylane as qml
diff --git a/pennylane/drawer/_add_obj.py b/pennylane/drawer/_add_obj.py
index ec90553ce..74d4d0e81 100644
--- a/pennylane/drawer/_add_obj.py
+++ b/pennylane/drawer/_add_obj.py
@@ -24,7 +24,10 @@ Key Features:
 Usage:
 The `_add_obj` function is automatically invoked by the text drawer when rendering a quantum circuit. Users typically do not need to call it directly.
 """
+
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
 # pylint: disable=unused-argument
+
 from functools import singledispatch
 
 from pennylane.measurements import (
@@ -74,7 +77,7 @@ def _add_cond_grouping_symbols(op, layer_str, config):
     return layer_str
 
 
-def _add_grouping_symbols(op, layer_str, config):  # pylint: disable=unused-argument
+def _add_grouping_symbols(op, layer_str, config):
     """Adds symbols indicating the extent of a given object."""
 
     if len(op.wires) > 1:
@@ -212,7 +215,7 @@ def _add_cwire_measurement(m, layer_str, config):
     layer_str = _add_cwire_measurement_grouping_symbols(mcms, layer_str, config)
 
     mv_label = "MCM"
-    meas_label = measurement_label_map[type(m)](mv_label)  # pylint: disable=protected-access
+    meas_label = measurement_label_map[type(m)](mv_label)
 
     n_wires = len(config.wire_map)
     for mcm in mcms:
diff --git a/pennylane/drawer/mpldrawer.py b/pennylane/drawer/mpldrawer.py
index 4a152a1d7..85b92319b 100644
--- a/pennylane/drawer/mpldrawer.py
+++ b/pennylane/drawer/mpldrawer.py
@@ -59,7 +59,7 @@ def _open_circ_options_process(options):
     return new_options
 
 
-# pylint: disable=too-many-instance-attributes, too-many-arguments
+# pylint: disable=too-many-arguments
 class MPLDrawer:
     r"""Allows easy creation of graphics representing circuits with matplotlib
 
diff --git a/pennylane/drawer/tape_mpl.py b/pennylane/drawer/tape_mpl.py
index 6aee78e82..ab638fb1e 100644
--- a/pennylane/drawer/tape_mpl.py
+++ b/pennylane/drawer/tape_mpl.py
@@ -18,7 +18,7 @@ Developer note: when making changes to this file, you can run
 `pennylane/doc/_static/tape_mpl/tape_mpl_examples.py` to generate docstring
 images.  If you change the docstring examples, please update this file.
 """
-# pylint: disable=no-member
+
 from __future__ import annotations
 
 from collections import namedtuple
@@ -39,7 +39,7 @@ from .utils import (
     unwrap_controls,
 )
 
-# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression)
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
 # pylint: disable=ungrouped-imports
 if TYPE_CHECKING:
     from pennylane.operation import Operator
diff --git a/pennylane/drawer/tape_text.py b/pennylane/drawer/tape_text.py
index 9f34abff5..5db64c61b 100644
--- a/pennylane/drawer/tape_text.py
+++ b/pennylane/drawer/tape_text.py
@@ -14,7 +14,7 @@
 """
 This module contains logic for the text based circuit drawer through the ``tape_text`` function.
 """
-# pylint: disable=too-many-arguments
+
 
 from dataclasses import dataclass, field
 from typing import Optional
diff --git a/pennylane/fermi/conversion.py b/pennylane/fermi/conversion.py
index 866757e58..08035003b 100644
--- a/pennylane/fermi/conversion.py
+++ b/pennylane/fermi/conversion.py
@@ -28,7 +28,6 @@ if TYPE_CHECKING:
     from pennylane.operation import Operator
 
 
-# pylint: disable=unexpected-keyword-arg
 def jordan_wigner(
     fermi_operator: Union[FermiWord, FermiSentence],
     ps: bool = False,
diff --git a/pennylane/fermi/fermionic.py b/pennylane/fermi/fermionic.py
index 2d0801f6e..a52277ed9 100644
--- a/pennylane/fermi/fermionic.py
+++ b/pennylane/fermi/fermionic.py
@@ -735,7 +735,6 @@ def _to_string(fermi_op, of=False):
     return " ".join(op_list).rstrip()
 
 
-# pylint: disable=too-few-public-methods
 class FermiC(FermiWord):
     r"""FermiC(orbital)
     The fermionic creation operator :math:`a^{\dagger}`
diff --git a/pennylane/fourier/qnode_spectrum.py b/pennylane/fourier/qnode_spectrum.py
index 435cc174d..0c66b14d8 100644
--- a/pennylane/fourier/qnode_spectrum.py
+++ b/pennylane/fourier/qnode_spectrum.py
@@ -382,7 +382,7 @@ def qnode_spectrum(qnode, encoding_args=None, argnum=None, decimals=8, validatio
         preprocessed non-linearly in the gate ``qml.RX(0.5*x**2, wires=0, id="x")``.
 
     """
-    # pylint: disable=too-many-branches,protected-access
+    # pylint: disable=too-many-branches
     validation_kwargs = validation_kwargs or {}
     encoding_args, argnum = _process_ids(encoding_args, argnum, qnode)
     atol = 10 ** (-decimals) if decimals is not None else 1e-10
diff --git a/pennylane/fourier/reconstruct.py b/pennylane/fourier/reconstruct.py
index 78b5bd26f..7f51199d2 100644
--- a/pennylane/fourier/reconstruct.py
+++ b/pennylane/fourier/reconstruct.py
@@ -120,7 +120,7 @@ def _reconstruct_gen(fun, spectrum, shifts=None, x0=None, f0=None, interface=Non
         callable: Reconstructed Fourier series with :math:`R` frequencies in ``spectrum`` .
         This function is a purely classical function. Furthermore, it is fully differentiable.
     """
-    # pylint: disable=unused-argument, too-many-arguments
+    # pylint: disable=too-many-arguments
 
     have_f0 = f0 is not None
     have_shifts = shifts is not None
diff --git a/pennylane/ftqc/graph_state_preparation.py b/pennylane/ftqc/graph_state_preparation.py
index bb5e8b8ba..ce85c10a1 100644
--- a/pennylane/ftqc/graph_state_preparation.py
+++ b/pennylane/ftqc/graph_state_preparation.py
@@ -231,7 +231,7 @@ class GraphStatePrep(Operation):
         graph: Union[nx.Graph, QubitGraph],
         one_qubit_ops: Operation = qml.H,
         two_qubit_ops: Operation = qml.CZ,
-    ):  # pylint: disable=arguments-differ, unused-argument
+    ):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators (static method).
 
         .. note::
diff --git a/pennylane/ftqc/lattice.py b/pennylane/ftqc/lattice.py
index 1134ed93d..c291f477d 100644
--- a/pennylane/ftqc/lattice.py
+++ b/pennylane/ftqc/lattice.py
@@ -10,7 +10,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=protected-access, inconsistent-return-statements
+
 """
 This file defines classes and functions for creating lattice objects that store topological
 connectivity information.
diff --git a/pennylane/ftqc/parametric_midmeasure.py b/pennylane/ftqc/parametric_midmeasure.py
index ec4a8058d..f062e0e8d 100644
--- a/pennylane/ftqc/parametric_midmeasure.py
+++ b/pennylane/ftqc/parametric_midmeasure.py
@@ -386,7 +386,6 @@ class ParametricMidMeasureMP(MidMeasureMP):
         )
         return (None, None), metadata
 
-    # pylint: disable=arguments-renamed, arguments-differ
     @property
     def hash(self):
         """int: Returns an integer hash uniquely representing the measurement process"""
@@ -400,7 +399,7 @@ class ParametricMidMeasureMP(MidMeasureMP):
 
         return hash(fingerprint)
 
-    # pylint: disable=too-many-positional-arguments
+    # pylint: disable=too-many-positional-arguments, arguments-differ, arguments-renamed
     @classmethod
     def _primitive_bind_call(
         cls, angle=0.0, wires=None, plane="ZX", reset=False, postselect=None, id=None
@@ -432,9 +431,7 @@ class ParametricMidMeasureMP(MidMeasureMP):
             f"{self.plane} plane not implemented. Available plans are 'XY' 'ZX' and 'YZ'."
         )
 
-    def label(
-        self, decimals: int = None, base_label: Iterable[str] = None, cache: dict = None
-    ):  # pylint: disable=unused-argument
+    def label(self, decimals: int = None, base_label: Iterable[str] = None, cache: dict = None):
         r"""How the mid-circuit measurement is represented in diagrams and drawings.
 
         Args:
@@ -471,7 +468,6 @@ class XMidMeasureMP(ParametricMidMeasureMP):
 
     _shortname = "measure_x"
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         wires: Optional[Wires],
@@ -495,9 +491,7 @@ class XMidMeasureMP(ParametricMidMeasureMP):
         """Representation of this class."""
         return f"{self._shortname}(wires={self.wires.tolist()})"
 
-    def label(
-        self, decimals: int = None, base_label: Iterable[str] = None, cache: dict = None
-    ):  # pylint: disable=unused-argument
+    def label(self, decimals: int = None, base_label: Iterable[str] = None, cache: dict = None):
         r"""How the mid-circuit measurement is represented in diagrams and drawings.
 
         Args:
@@ -532,7 +526,6 @@ class YMidMeasureMP(ParametricMidMeasureMP):
 
     _shortname = "measure_y"
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         wires: Optional[Wires],
@@ -561,9 +554,7 @@ class YMidMeasureMP(ParametricMidMeasureMP):
         """Representation of this class."""
         return f"{self._shortname}(wires={self.wires.tolist()})"
 
-    def label(
-        self, decimals: int = None, base_label: str = None, cache: dict = None
-    ):  # pylint: disable=unused-argument
+    def label(self, decimals: int = None, base_label: str = None, cache: dict = None):
         r"""How the mid-circuit measurement is represented in diagrams and drawings.
 
         Args:
diff --git a/pennylane/gradients/adjoint_metric_tensor.py b/pennylane/gradients/adjoint_metric_tensor.py
index 9e2fa7e1d..7a6208203 100644
--- a/pennylane/gradients/adjoint_metric_tensor.py
+++ b/pennylane/gradients/adjoint_metric_tensor.py
@@ -21,8 +21,6 @@ import numpy as np
 
 from pennylane import math
 from pennylane.devices.qubit import apply_operation, create_initial_state
-
-# pylint: disable=too-many-statements,unused-argument
 from pennylane.gradients.metric_tensor import _contract_metric_tensor_with_cjac
 from pennylane.ops import StatePrep, adjoint
 from pennylane.ops.functions import generator, map_wires
@@ -44,7 +42,7 @@ def _group_operations(tape):
     # Extract tape operations list
     ops = tape.operations
     # Find the indices of trainable operations in the tape operations list
-    # pylint: disable=protected-access
+
     trainable_par_info = [tape.par_info[i] for i in tape.trainable_params]
     trainables = [info["op_idx"] for info in trainable_par_info]
     # Add the indices incremented by one to the trainable indices
diff --git a/pennylane/gradients/classical_jacobian.py b/pennylane/gradients/classical_jacobian.py
index 348b2caa3..ccd6d5db6 100644
--- a/pennylane/gradients/classical_jacobian.py
+++ b/pennylane/gradients/classical_jacobian.py
@@ -151,7 +151,7 @@ def classical_jacobian(qnode, argnum=None, expand_fn=None, trainable_only=True):
 
     wrapper_argnum = argnum if argnum is not None else None
 
-    def qnode_wrapper(*args, **kwargs):  # pylint: disable=inconsistent-return-statements
+    def qnode_wrapper(*args, **kwargs):
         old_interface = qnode.interface
 
         if old_interface == "auto":
diff --git a/pennylane/gradients/finite_difference.py b/pennylane/gradients/finite_difference.py
index 8ff9ad61c..26903da22 100644
--- a/pennylane/gradients/finite_difference.py
+++ b/pennylane/gradients/finite_difference.py
@@ -19,7 +19,7 @@ import functools
 from functools import partial
 from typing import Callable, Literal
 
-# pylint: disable=protected-access,too-many-arguments,too-many-branches,too-many-statements,unused-argument
+# pylint: disable=too-many-arguments,too-many-branches,too-many-statements,unused-argument
 from warnings import warn
 
 import numpy as np
diff --git a/pennylane/gradients/general_shift_rules.py b/pennylane/gradients/general_shift_rules.py
index 67619b15a..f7c3981b7 100644
--- a/pennylane/gradients/general_shift_rules.py
+++ b/pennylane/gradients/general_shift_rules.py
@@ -185,7 +185,9 @@ def _get_shift_rule(frequencies, shifts=None):
         coeffs = -2 * linalg_solve(sin_matrix.T, frequencies)
 
     coeffs = np.concatenate((coeffs, -coeffs))
-    shifts = np.concatenate((shifts, -shifts))  # pylint: disable=invalid-unary-operand-type
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=invalid-unary-operand-type
+    shifts = np.concatenate((shifts, -shifts))
     return np.stack([coeffs, shifts]).T
 
 
@@ -423,7 +425,6 @@ def _copy_and_shift_params(tape, indices, shifts, multipliers, cast=False):
             mp = all_ops[op_idx].__class__
             all_ops[op_idx] = mp(obs=shifted_op)
 
-    # pylint: disable=protected-access
     ops = all_ops[: len(tape.operations)]
     meas = all_ops[len(tape.operations) :]
     return QuantumScript(ops=ops, measurements=meas, shots=tape.shots)
diff --git a/pennylane/gradients/gradient_transform.py b/pennylane/gradients/gradient_transform.py
index 44956f412..bf7672745 100644
--- a/pennylane/gradients/gradient_transform.py
+++ b/pennylane/gradients/gradient_transform.py
@@ -174,7 +174,6 @@ def _try_zero_grad_from_graph_or_get_grad_method(tape, param_index, use_graph=Tr
 
     """
 
-    # pylint:disable=protected-access
     par_info = tape.par_info[param_index]
 
     if use_graph:
diff --git a/pennylane/gradients/jvp.py b/pennylane/gradients/jvp.py
index 578d0ef3e..d9f21826c 100644
--- a/pennylane/gradients/jvp.py
+++ b/pennylane/gradients/jvp.py
@@ -317,7 +317,7 @@ def jvp(tape, tangent, gradient_fn, gradient_kwargs=None):
             # corresponding element of the JVP will be zero,
             # and we can avoid a quantum computation.
 
-            def func(_):  # pylint: disable=unused-argument
+            def func(_):
                 # TODO: Update shape for CV variables and for qutrit simulations
                 res = tuple(_single_measurement_zero(m, tangent) for m in tape.measurements)
                 if not multi_m:
@@ -417,7 +417,7 @@ def batch_jvp(tapes, tangents, gradient_fn, reduction="append", gradient_kwargs=
 
     We have two JVPs; one per tape. Each one corresponds to the shape of the output of their respective tape.
     """
-    # pylint: disable=too-many-arguments
+
     gradient_kwargs = gradient_kwargs or {}
     reshape_info = []
     gradient_tapes = []
diff --git a/pennylane/gradients/metric_tensor.py b/pennylane/gradients/metric_tensor.py
index 4317184b1..5d220458c 100644
--- a/pennylane/gradients/metric_tensor.py
+++ b/pennylane/gradients/metric_tensor.py
@@ -79,9 +79,7 @@ def _expand_metric_tensor(
     allow_nonunitary=True,
     aux_wire=None,
     device_wires=None,
-) -> tuple[
-    QuantumScriptBatch, PostprocessingFn
-]:  # pylint: disable=too-many-arguments, too-many-positional-arguments
+) -> tuple[QuantumScriptBatch, PostprocessingFn]:
     """Set the metric tensor based on whether non-unitary gates are allowed."""
     # pylint: disable=unused-argument,too-many-arguments
 
diff --git a/pennylane/gradients/parameter_shift.py b/pennylane/gradients/parameter_shift.py
index 7b6dbf022..366e05932 100644
--- a/pennylane/gradients/parameter_shift.py
+++ b/pennylane/gradients/parameter_shift.py
@@ -56,7 +56,7 @@ from .gradient_transform import (
     reorder_grads,
 )
 
-# pylint: disable=protected-access,too-many-arguments,too-many-statements,unused-argument
+# pylint: disable=too-many-arguments,unused-argument
 
 
 NONINVOLUTORY_OBS = {
diff --git a/pennylane/gradients/parameter_shift_hessian.py b/pennylane/gradients/parameter_shift_hessian.py
index 6e1c97680..83c96d6b0 100644
--- a/pennylane/gradients/parameter_shift_hessian.py
+++ b/pennylane/gradients/parameter_shift_hessian.py
@@ -298,7 +298,7 @@ def expval_hessian_param_shift(tape, argnum, method_map, diagonal_shifts, off_di
         function to be applied to the results of the evaluated tapes
         in order to obtain the Hessian matrix.
     """
-    # pylint: disable=too-many-arguments, too-many-statements
+    # pylint: disable=too-many-arguments
     h_dim = tape.num_params
 
     unshifted_coeffs = {}
@@ -412,7 +412,6 @@ def expval_hessian_param_shift(tape, argnum, method_map, diagonal_shifts, off_di
     return hessian_tapes, processing_fn
 
 
-# pylint: disable=too-many-return-statements,too-many-branches
 def contract_qjac_with_cjac(qhess, cjac, tape):
     """Contract a quantum Jacobian with a classical preprocessing Jacobian."""
     qhess = (qhess,)
@@ -631,7 +630,9 @@ def param_shift_hessian(
     for i, g in diff_methods.items():
         if g == "0":
             bool_argnum[i] = bool_argnum[:, i] = False
-    if math.all(~bool_argnum):  # pylint: disable=invalid-unary-operand-type
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=invalid-unary-operand-type
+    if math.all(~bool_argnum):
         return _all_zero_hessian(tape)
 
     # If any of these argument indices correspond to a finite difference
diff --git a/pennylane/gradients/pulse_gradient.py b/pennylane/gradients/pulse_gradient.py
index fc6cff41f..7009fd6aa 100644
--- a/pennylane/gradients/pulse_gradient.py
+++ b/pennylane/gradients/pulse_gradient.py
@@ -601,7 +601,7 @@ def stoch_pulse_grad(
         classical Jacobian, which is *not* constant over :math:`\tau`.
         Therefore, it is important to implement pulses in the simplest way possible.
     """
-    # pylint:disable=unused-argument
+
     transform_name = "stochastic pulse parameter-shift"
     _assert_has_jax(transform_name)
     assert_no_state_returns(tape.measurements, transform_name)
@@ -778,7 +778,6 @@ def _tapes_data_hardware(tape, operation, key, num_split_times, use_broadcasting
     return tapes, data
 
 
-# pylint: disable=too-many-arguments
 def _expval_stoch_pulse_grad(tape, argnum, num_split_times, key, use_broadcasting):
     r"""Compute the gradient of a quantum circuit composed of pulse sequences that measures
     an expectation value or probabilities, by applying the stochastic parameter shift rule.
diff --git a/pennylane/gradients/spsa_gradient.py b/pennylane/gradients/spsa_gradient.py
index d8e6a1919..678bb55f5 100644
--- a/pennylane/gradients/spsa_gradient.py
+++ b/pennylane/gradients/spsa_gradient.py
@@ -36,7 +36,7 @@ from .gradient_transform import (
     find_and_validate_gradient_methods,
 )
 
-# pylint: disable=protected-access,too-many-arguments,too-many-branches,too-many-statements,unused-argument
+# pylint: disable=too-many-arguments,unused-argument
 
 
 def _rademacher_sampler(indices, num_params, *args, rng):
diff --git a/pennylane/gradients/vjp.py b/pennylane/gradients/vjp.py
index 04cc145d8..46e617370 100644
--- a/pennylane/gradients/vjp.py
+++ b/pennylane/gradients/vjp.py
@@ -17,7 +17,7 @@ of tapes.
 """
 import autograd
 
-# pylint: disable=no-member, too-many-branches
+# pylint: disable=too-many-branches
 import numpy as np
 
 from pennylane import math
@@ -120,6 +120,8 @@ def compute_vjp_single(dy, jac, num=None):
     # TODO: Excplictly catalogue and update raises for known types.
 
     # Single measurement with a single param
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=no-member
     if not isinstance(jac, (tuple, list, autograd.builtins.SequenceBox)):
         # No trainable parameters
         if jac.shape == (0,):
@@ -200,6 +202,8 @@ def compute_vjp_multi(dy, jac, num=None):
         return None
 
     # Single parameter
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=no-member
     if not isinstance(jac[0], (tuple, autograd.builtins.SequenceBox)):
         res = []
         for d, j_ in zip(dy, jac):
@@ -378,7 +382,6 @@ def vjp(tape, dy, gradient_fn, gradient_kwargs=None):
     return gradient_tapes, processing_fn
 
 
-# pylint: disable=too-many-arguments
 def batch_vjp(tapes, dys, gradient_fn, reduction="append", gradient_kwargs=None):
     r"""Generate the gradient tapes and processing function required to compute
     the vector-Jacobian products of a batch of tapes.
diff --git a/pennylane/io/io.py b/pennylane/io/io.py
index 81daed30e..058506e00 100644
--- a/pennylane/io/io.py
+++ b/pennylane/io/io.py
@@ -37,7 +37,7 @@ _MISSING_QISKIT_PLUGIN_MESSAGE = (
 __plugin_devices = (
     defaultdict(tuple, metadata.entry_points())["pennylane.io"]
     if version_info[:2] == (3, 9)
-    else metadata.entry_points(group="pennylane.io")  # pylint:disable=unexpected-keyword-arg
+    else metadata.entry_points(group="pennylane.io")
 )
 plugin_converters = {entry.name: entry for entry in __plugin_devices}
 
diff --git a/pennylane/io/qualtran_io.py b/pennylane/io/qualtran_io.py
index 148c2f3f2..82587059a 100644
--- a/pennylane/io/qualtran_io.py
+++ b/pennylane/io/qualtran_io.py
@@ -14,6 +14,10 @@
 """
 This submodule contains the adapter class for Qualtran-PennyLane interoperability.
 """
+
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=unused-argument
+
 from collections import defaultdict
 from functools import lru_cache, singledispatch
 
@@ -30,7 +34,6 @@ except (ModuleNotFoundError, ImportError) as import_error:
     pass
 
 
-# pylint: disable=unused-argument
 @lru_cache
 def _get_to_pl_op():
     @singledispatch
@@ -406,9 +409,9 @@ class FromBloq(Operation):
         matrix = bloq.tensor_contract()
         return matrix.shape == (2 ** len(self.wires), 2 ** len(self.wires))
 
-    def compute_matrix(
-        *params, **hyperparams
-    ):  # pylint: disable=no-method-argument, no-self-argument
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=no-method-argument
+    def compute_matrix(*params, **hyperparams):  # pylint: disable=no-self-argument
         bloq = hyperparams["bloq"]
         matrix = bloq.tensor_contract()
 
diff --git a/pennylane/labs/dla/dense_util.py b/pennylane/labs/dla/dense_util.py
index 352316bdd..eaa39b5c7 100644
--- a/pennylane/labs/dla/dense_util.py
+++ b/pennylane/labs/dla/dense_util.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Utility tools for dense Lie algebra representations"""
-# pylint: disable=too-many-return-statements, missing-function-docstring, possibly-used-before-assignment
+
 from functools import reduce
 from itertools import combinations
 from typing import Iterable, Optional, Union
diff --git a/pennylane/labs/resource_estimation/ops/op_math/symbolic.py b/pennylane/labs/resource_estimation/ops/op_math/symbolic.py
index a1f7d2463..e34fc9c83 100644
--- a/pennylane/labs/resource_estimation/ops/op_math/symbolic.py
+++ b/pennylane/labs/resource_estimation/ops/op_math/symbolic.py
@@ -26,7 +26,7 @@ from pennylane.ops.op_math.pow import PowOperation
 from pennylane.ops.op_math.prod import Prod
 from pennylane.pauli import PauliSentence
 
-# pylint: disable=too-many-ancestors,arguments-differ,protected-access,too-many-arguments,too-many-positional-arguments
+# pylint: disable=too-many-ancestors,arguments-differ,too-many-arguments,too-many-positional-arguments
 
 
 class ResourceAdjoint(AdjointOperation, re.ResourceOperator):
diff --git a/pennylane/labs/resource_estimation/templates/stateprep.py b/pennylane/labs/resource_estimation/templates/stateprep.py
index 291ac6051..ca7d52690 100644
--- a/pennylane/labs/resource_estimation/templates/stateprep.py
+++ b/pennylane/labs/resource_estimation/templates/stateprep.py
@@ -19,7 +19,7 @@ import pennylane as qml
 from pennylane.labs import resource_estimation as re
 from pennylane.labs.resource_estimation import CompressedResourceOp, ResourceOperator
 
-# pylint: disable=arguments-differ, protected-access
+# pylint: disable=arguments-differ
 
 
 class ResourceStatePrep(qml.StatePrep, ResourceOperator):
diff --git a/pennylane/labs/resource_estimation/templates/subroutines.py b/pennylane/labs/resource_estimation/templates/subroutines.py
index d2f7e8578..f0822cd3c 100644
--- a/pennylane/labs/resource_estimation/templates/subroutines.py
+++ b/pennylane/labs/resource_estimation/templates/subroutines.py
@@ -1437,7 +1437,7 @@ class ResourceQROM(qml.QROM, ResourceOperator):
     @classmethod
     def resource_rep(
         cls, num_bitstrings, num_bit_flips, num_control_wires, num_work_wires, size_bitstring, clean
-    ) -> CompressedResourceOp:  # pylint: disable=too-many-arguments
+    ) -> CompressedResourceOp:
         r"""Returns a compressed representation containing only the parameters of
         the Operator that are needed to compute a resource estimation.
 
diff --git a/pennylane/labs/resource_estimation/templates/trotter.py b/pennylane/labs/resource_estimation/templates/trotter.py
index c8e7b3f0c..25ef9b152 100644
--- a/pennylane/labs/resource_estimation/templates/trotter.py
+++ b/pennylane/labs/resource_estimation/templates/trotter.py
@@ -32,9 +32,9 @@ from pennylane.templates.subroutines.trotter import TrotterizedQfunc
 # pylint: disable=arguments-differ
 
 
-class ResourceTrotterProduct(
-    TrotterProduct, ResourceOperator
-):  # pylint: disable=too-many-ancestors
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=too-many-ancestors
+class ResourceTrotterProduct(TrotterProduct, ResourceOperator):
     r"""An operation representing the Suzuki-Trotter product approximation for the complex matrix
     exponential of a given Hamiltonian.
 
diff --git a/pennylane/labs/trotter_error/realspace/realspace_coefficients.py b/pennylane/labs/trotter_error/realspace/realspace_coefficients.py
index 3fad86054..3276ebcdd 100644
--- a/pennylane/labs/trotter_error/realspace/realspace_coefficients.py
+++ b/pennylane/labs/trotter_error/realspace/realspace_coefficients.py
@@ -72,7 +72,9 @@ class RealspaceCoeffs:
     def _from_tree(cls, tree: _RealspaceTree):
         """Initialize directly from a ``_RealspaceTree`` object."""
         rs_coeffs = cls.__new__(cls)
-        rs_coeffs._tree = tree  # pylint: disable=protected-access
+        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+        # pylint: disable=protected-access
+        rs_coeffs._tree = tree
         return rs_coeffs
 
     def __add__(self, other: RealspaceCoeffs) -> RealspaceCoeffs:
diff --git a/pennylane/labs/trotter_error/realspace/realspace_operator.py b/pennylane/labs/trotter_error/realspace/realspace_operator.py
index 4ea16e67c..cab8318ba 100644
--- a/pennylane/labs/trotter_error/realspace/realspace_operator.py
+++ b/pennylane/labs/trotter_error/realspace/realspace_operator.py
@@ -266,7 +266,7 @@ class RealspaceSum(Fragment):
     """
 
     def __init__(self, modes: int, ops: Sequence[RealspaceOperator]):
-        # pylint: disable=unnecessary-lambda, protected-access
+        # pylint: disable=protected-access
         for op in ops:
             if op.modes != modes:
                 raise ValueError(
diff --git a/pennylane/labs/vibrational/pes_generator.py b/pennylane/labs/vibrational/pes_generator.py
index 632c2193e..76ea3f5be 100644
--- a/pennylane/labs/vibrational/pes_generator.py
+++ b/pennylane/labs/vibrational/pes_generator.py
@@ -29,7 +29,7 @@ from pennylane.qchem.vibrational.vibrational_class import (
     _single_point,
 )
 
-# pylint: disable=too-many-arguments, too-many-function-args, too-many-branches
+# pylint: disable=too-many-arguments,too-many-function-args
 # pylint: disable= import-outside-toplevel, too-many-positional-arguments
 
 # constants
diff --git a/pennylane/liealg/cartan_decomp.py b/pennylane/liealg/cartan_decomp.py
index 0722b9c2b..2df9f8f9f 100644
--- a/pennylane/liealg/cartan_decomp.py
+++ b/pennylane/liealg/cartan_decomp.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Functionality for Cartan decomposition"""
-# pylint: disable= missing-function-docstring
+
 from typing import List, Tuple, Union
 
 from pennylane import math
diff --git a/pennylane/liealg/involutions.py b/pennylane/liealg/involutions.py
index 6d8c3d595..7ceb585b1 100644
--- a/pennylane/liealg/involutions.py
+++ b/pennylane/liealg/involutions.py
@@ -13,8 +13,6 @@
 # limitations under the License.
 """Cartan involutions"""
 from functools import singledispatch
-
-# pylint: disable=missing-function-docstring
 from typing import Optional, Union
 
 import numpy as np
@@ -124,7 +122,7 @@ def AI(op: Union[np.ndarray, PauliSentence, Operator]) -> bool:
 
 
 @singledispatch
-def _AI(op):  # pylint:disable=unused-argument
+def _AI(op):
     r"""Default implementation of the canonical form of the AI involution
     :math:`\theta: x \mapsto x^\ast`.
     """
@@ -184,7 +182,7 @@ def AII(op: Union[np.ndarray, PauliSentence, Operator], wire: Optional[int] = No
 
 
 @singledispatch
-def _AII(op, wire=None):  # pylint:disable=unused-argument
+def _AII(op, wire=None):
     r"""Default implementation of the canonical form of the AII involution
     :math:`\theta: x \mapsto Y_0 x^\ast Y_0`.
     """
@@ -266,7 +264,7 @@ def AIII(
 
 
 @singledispatch
-def _AIII(op, p=None, q=None, wire=None):  # pylint:disable=unused-argument
+def _AIII(op, p=None, q=None, wire=None):
     r"""Default implementation of the canonical form of the AIII involution
     :math:`\theta: x \mapsto I_{p,q} x I_{p,q}`.
     """
@@ -387,7 +385,7 @@ def DIII(op: Union[np.ndarray, PauliSentence, Operator], wire: Optional[int] = N
 
 
 @singledispatch
-def _DIII(op, wire=None):  # pylint:disable=unused-argument
+def _DIII(op, wire=None):
     r"""Default implementation of the canonical form of the DIII involution
     :math:`\theta: x \mapsto Y_0 x Y_0`.
     """
@@ -511,7 +509,7 @@ def CII(
 
 
 @singledispatch
-def _CII(op, p=None, q=None, wire=None):  # pylint:disable=unused-argument
+def _CII(op, p=None, q=None, wire=None):
     r"""Default implementation of the canonical form of the CII involution
     :math:`\theta: x \mapsto K_{p,q} x K_{p,q}`.
     """
@@ -592,7 +590,7 @@ def even_odd_involution(op: Union[PauliSentence, np.ndarray, Operator]) -> bool:
 
 
 @singledispatch
-def _even_odd_involution(op):  # pylint:disable=unused-argument, missing-function-docstring
+def _even_odd_involution(op):
     raise NotImplementedError(f"Involution not implemented for operator {op} of type {type(op)}")
 
 
diff --git a/pennylane/math/fidelity.py b/pennylane/math/fidelity.py
index 889cb26ab..485358261 100644
--- a/pennylane/math/fidelity.py
+++ b/pennylane/math/fidelity.py
@@ -325,9 +325,11 @@ def _register_torch_vjp():
     """
     Register the custom VJP for torch
     """
-    # pylint: disable=import-outside-toplevel,abstract-method,arguments-differ
+    # pylint: disable=import-outside-toplevel
     import torch
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=abstract-method, arguments-differ
     class _TorchFidelity(torch.autograd.Function):
         @staticmethod
         def forward(ctx, dm0, dm1):
diff --git a/pennylane/math/is_independent.py b/pennylane/math/is_independent.py
index 9ad2d30fc..c6963b4c4 100644
--- a/pennylane/math/is_independent.py
+++ b/pennylane/math/is_independent.py
@@ -251,7 +251,7 @@ def _is_indep_numerical(func, interface, args, kwargs, num_pos, seed, atol, rtol
     return True
 
 
-# pylint:disable=too-many-arguments,too-many-positional-arguments
+# pylint: disable=too-many-positional-arguments
 def is_independent(
     func,
     interface,
diff --git a/pennylane/math/matrix_manipulation.py b/pennylane/math/matrix_manipulation.py
index 52627775b..09b7ed7e8 100644
--- a/pennylane/math/matrix_manipulation.py
+++ b/pennylane/math/matrix_manipulation.py
@@ -25,8 +25,8 @@ from scipy.sparse import csr_matrix, eye, kron
 from pennylane import math
 
 
+# pylint: disable=too-many-branches
 def expand_matrix(mat, wires: Union[Sequence, int], wire_order=None, sparse_format="csr"):
-    # pylint: disable=too-many-branches
     """Re-express a matrix acting on a subspace defined by a set of wire labels
     according to a global wire order.
 
diff --git a/pennylane/math/quantum.py b/pennylane/math/quantum.py
index 6e90988de..766022799 100644
--- a/pennylane/math/quantum.py
+++ b/pennylane/math/quantum.py
@@ -13,8 +13,6 @@
 # limitations under the License.
 """Differentiable quantum functions"""
 import functools
-
-# pylint: disable=import-outside-toplevel
 import itertools
 from string import ascii_letters
 
@@ -1204,7 +1202,7 @@ def relative_entropy(state0, state1, base=None, check_state=False, c_dtype="comp
         state1 = math.cast_like(state1, state0)
 
     if check_state:
-        # pylint: disable=expression-not-assigned
+
         _check_density_matrix(state0)
         _check_density_matrix(state1)
 
diff --git a/pennylane/math/single_dispatch.py b/pennylane/math/single_dispatch.py
index 0fa89aef7..de635c85a 100644
--- a/pennylane/math/single_dispatch.py
+++ b/pennylane/math/single_dispatch.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 """Autoray registrations"""
 
-# pylint:disable=protected-access,import-outside-toplevel,wrong-import-position, disable=unnecessary-lambda
+# pylint: disable=protected-access,import-outside-toplevel,disable=unnecessary-lambda
 from importlib import import_module
 
 # pylint: disable=wrong-import-order
diff --git a/pennylane/math/utils.py b/pennylane/math/utils.py
index 812c51e10..20ac1ac82 100644
--- a/pennylane/math/utils.py
+++ b/pennylane/math/utils.py
@@ -202,7 +202,7 @@ def allclose(a, b, rtol=1e-05, atol=1e-08, **kwargs):
             return _allclose_sparse_scalar(b, a, rtol=rtol, atol=atol)
 
         if sp.sparse.issparse(a):
-            # pylint: disable=arguments-out-of-order
+
             return _allclose_mixed(a, b, rtol=rtol, atol=atol, b_is_sparse=False)
         if sp.sparse.issparse(b):
             return _allclose_mixed(a, b, rtol=rtol, atol=atol, b_is_sparse=True)
diff --git a/pennylane/measurements/expval.py b/pennylane/measurements/expval.py
index 82a4a079b..7bc61c956 100644
--- a/pennylane/measurements/expval.py
+++ b/pennylane/measurements/expval.py
@@ -144,9 +144,7 @@ class ExpectationMP(SampleMeasurement, StateMeasurement):
             probs = qml.probs(wires=self.wires).process_counts(counts=counts, wire_order=wire_order)
         return self._calculate_expectation(probs)
 
-    def process_density_matrix(
-        self, density_matrix: Sequence[complex], wire_order: Wires
-    ):  # pylint: disable=unused-argument
+    def process_density_matrix(self, density_matrix: Sequence[complex], wire_order: Wires):
         if not self.wires:
             return qml.math.squeeze(self.eigvals())
         with qml.queuing.QueuingManager.stop_recording():
diff --git a/pennylane/measurements/measurements.py b/pennylane/measurements/measurements.py
index a0086b22b..e158e98cf 100644
--- a/pennylane/measurements/measurements.py
+++ b/pennylane/measurements/measurements.py
@@ -50,8 +50,6 @@ class MeasurementProcess(ABC, metaclass=qml.capture.ABCCaptureMeta):
             where the instance has to be identified
     """
 
-    # pylint:disable=too-many-instance-attributes
-
     _shortname = None
 
     _obs_primitive: Optional["jax.extend.core.Primitive"] = None
@@ -145,7 +143,6 @@ class MeasurementProcess(ABC, metaclass=qml.capture.ABCCaptureMeta):
             return cls(eigvals=data[1], **dict(metadata))
         return cls(**dict(metadata))
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         obs: Optional[
diff --git a/pennylane/measurements/mutual_info.py b/pennylane/measurements/mutual_info.py
index 0bf99d22d..5e11e419e 100644
--- a/pennylane/measurements/mutual_info.py
+++ b/pennylane/measurements/mutual_info.py
@@ -111,7 +111,6 @@ class MutualInfoMP(StateMeasurement):
         metadata = (("wires", tuple(self.raw_wires)), ("log_base", self.log_base))
         return (None, None), metadata
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         wires: Optional[Sequence[Wires]] = None,
diff --git a/pennylane/measurements/null_measurement.py b/pennylane/measurements/null_measurement.py
index ad1fc816d..6dd86bd25 100644
--- a/pennylane/measurements/null_measurement.py
+++ b/pennylane/measurements/null_measurement.py
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=protected-access
+
 """
 This module contains the qml.mutual_info measurement.
 """
diff --git a/pennylane/measurements/shots.py b/pennylane/measurements/shots.py
index 9268d1a53..aae33664c 100644
--- a/pennylane/measurements/shots.py
+++ b/pennylane/measurements/shots.py
@@ -12,8 +12,6 @@
 # limitations under the License.
 """This module contains the Shots class to hold shot-related information."""
 from collections.abc import Sequence
-
-# pylint:disable=inconsistent-return-statements
 from typing import NamedTuple, Union
 
 
diff --git a/pennylane/measurements/var.py b/pennylane/measurements/var.py
index cfe5340f4..50ab3874b 100644
--- a/pennylane/measurements/var.py
+++ b/pennylane/measurements/var.py
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=protected-access
+
 """
 This module contains the qml.var measurement.
 """
diff --git a/pennylane/measurements/vn_entropy.py b/pennylane/measurements/vn_entropy.py
index 0d2eba1f9..945289576 100644
--- a/pennylane/measurements/vn_entropy.py
+++ b/pennylane/measurements/vn_entropy.py
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=protected-access
+
 """
 This module contains the qml.vn_entropy measurement.
 """
@@ -98,7 +98,6 @@ class VnEntropyMP(StateMeasurement):
         metadata = (("wires", self.raw_wires), ("log_base", self.log_base))
         return (None, None), metadata
 
-    # pylint: disable=too-many-arguments, unused-argument
     def __init__(
         self,
         wires: Optional[Wires] = None,
diff --git a/pennylane/numpy/__init__.py b/pennylane/numpy/__init__.py
index 200957e94..bdce6ba98 100644
--- a/pennylane/numpy/__init__.py
+++ b/pennylane/numpy/__init__.py
@@ -80,7 +80,7 @@ For more details, please consult the `Autograd
 docs <https://github.com/HIPS/autograd/blob/master/docs/tutorial.md>`__.
 
 """
-# pylint: disable=wrong-import-position,wildcard-import,undefined-variable
+# pylint: disable=wrong-import-position,undefined-variable
 from autograd import numpy as _np
 from autograd.numpy import *
 
diff --git a/pennylane/numpy/tensor.py b/pennylane/numpy/tensor.py
index 191824724..31f51d521 100644
--- a/pennylane/numpy/tensor.py
+++ b/pennylane/numpy/tensor.py
@@ -130,7 +130,6 @@ class tensor(_np.ndarray):
         return super().__array_wrap__(out_arr)
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
-        # pylint: disable=no-member,attribute-defined-outside-init
 
         # unwrap any outputs the ufunc might have
         outputs = [i.view(onp.ndarray) for i in kwargs.get("out", ())]
@@ -208,7 +207,7 @@ class tensor(_np.ndarray):
     def __setstate__(self, reduced_obj) -> None:
         # Called when unpickling the object.
         # Set self.requires_grad with the last element in the tuple returned by __reduce__:
-        # pylint: disable=attribute-defined-outside-init,no-member
+        # pylint: disable=attribute-defined-outside-init
         self.requires_grad = reduced_obj[-1]
         # And call parent's __setstate__ without this element:
         super().__setstate__(reduced_obj[:-1])
diff --git a/pennylane/operation.py b/pennylane/operation.py
index 5a602cb7b..e9ff0cb65 100644
--- a/pennylane/operation.py
+++ b/pennylane/operation.py
@@ -10,7 +10,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=protected-access, no-member
+# pylint: disable=protected-access
 r"""
 This module contains the abstract base classes for defining PennyLane
 operations and observables.
@@ -216,7 +216,7 @@ these objects are located in ``pennylane.ops.qubit.attributes``, not ``pennylane
     ~ops.qubit.attributes.symmetric_over_control_wires
 
 """
-# pylint:disable=access-member-before-definition,global-statement
+# pylint: disable=access-member-before-definition
 import abc
 import copy
 import warnings
@@ -338,7 +338,6 @@ class _WiresEnum(IntEnum):
 class ClassPropertyDescriptor:  # pragma: no cover
     """Allows a class property to be defined"""
 
-    # pylint: disable=too-few-public-methods,too-many-public-methods
     def __init__(self, fget, fset=None):
         self.fget = fget
         self.fset = fset
@@ -788,9 +787,7 @@ class Operator(abc.ABC, metaclass=ABCCaptureMeta):
         return self.hash
 
     @staticmethod
-    def compute_matrix(
-        *params: TensorLike, **hyperparams: dict[str, Any]
-    ) -> TensorLike:  # pylint:disable=unused-argument
+    def compute_matrix(*params: TensorLike, **hyperparams: dict[str, Any]) -> TensorLike:
         r"""Representation of the operator as a canonical matrix in the computational basis (static method).
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
@@ -853,7 +850,7 @@ class Operator(abc.ABC, metaclass=ABCCaptureMeta):
     @staticmethod
     def compute_sparse_matrix(
         *params: TensorLike, format: str = "csr", **hyperparams: dict[str, Any]
-    ) -> spmatrix:  # pylint:disable=unused-argument
+    ) -> spmatrix:
         r"""Representation of the operator as a sparse matrix in the computational basis (static method).
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
@@ -1110,7 +1107,6 @@ class Operator(abc.ABC, metaclass=ABCCaptureMeta):
         wires: Optional[WiresLike] = None,
         id: Optional[str] = None,
     ):
-        # pylint: disable=too-many-branches
 
         self._name: str = self.__class__.__name__  #: str: name of the operator
         self._id: str = id
@@ -1459,7 +1455,7 @@ class Operator(abc.ABC, metaclass=ABCCaptureMeta):
     @staticmethod
     def compute_diagonalizing_gates(
         *params: TensorLike, wires: WiresLike, **hyperparams: dict[str, Any]
-    ) -> list["Operator"]:  # pylint: disable=unused-argument
+    ) -> list["Operator"]:
         r"""Sequence of gates that diagonalize the operator in the computational basis (static method).
 
         Given the eigendecomposition :math:`O = U \Sigma U^{\dagger}` where
@@ -1502,7 +1498,7 @@ class Operator(abc.ABC, metaclass=ABCCaptureMeta):
             *self.parameters, wires=self.wires, **self.hyperparameters
         )
 
-    # pylint: disable=no-self-argument, comparison-with-callable
+    # pylint: disable=no-self-argument
     @classproperty
     def has_generator(cls) -> bool:
         r"""Bool: Whether or not the Operator returns a defined generator.
@@ -1571,7 +1567,7 @@ class Operator(abc.ABC, metaclass=ABCCaptureMeta):
         """
         return "_ops"
 
-    # pylint: disable=no-self-argument, comparison-with-callable
+    # pylint: disable=no-self-argument
     @classproperty
     def has_adjoint(cls) -> bool:
         r"""Bool: Whether or not the Operator can compute its own adjoint.
@@ -1613,7 +1609,7 @@ class Operator(abc.ABC, metaclass=ABCCaptureMeta):
             new_op._pauli_rep = p_rep.map_wires(wire_map)
         return new_op
 
-    def simplify(self) -> "Operator":  # pylint: disable=unused-argument
+    def simplify(self) -> "Operator":
         """Reduce the depth of nested operators to the minimum.
 
         Returns:
@@ -1935,13 +1931,9 @@ class Channel(Operation, abc.ABC):
             can be useful for some applications where the instance has to be identified
     """
 
-    # pylint: disable=abstract-method
-
     @staticmethod
     @abc.abstractmethod
-    def compute_kraus_matrices(
-        *params, **hyperparams
-    ) -> list[np.ndarray]:  # pylint:disable=unused-argument
+    def compute_kraus_matrices(*params, **hyperparams) -> list[np.ndarray]:
         """Kraus matrices representing a quantum channel, specified in
         the computational basis.
 
@@ -2123,8 +2115,6 @@ class CVOperation(CV, Operation):
             can be useful for some applications where the instance has to be identified
     """
 
-    # pylint: disable=abstract-method
-
     @classproperty
     def supports_parameter_shift(self):
         """Returns True iff the CV Operation supports the parameter-shift differentiation method.
@@ -2165,7 +2155,7 @@ class CVOperation(CV, Operation):
         for c, _a, s in param_shift:
             # evaluate the transform at the shifted parameter values
             p[idx] = _a * original_p_idx + s
-            U = self._heisenberg_rep(p)  # pylint: disable=assignment-from-none
+            U = self._heisenberg_rep(p)
 
             if pd is None:
                 pd = c * U
@@ -2208,7 +2198,7 @@ class CVOperation(CV, Operation):
                 p[0] = np.linalg.inv(p[0])
             except np.linalg.LinAlgError:
                 p[0] = -p[0]  # negate first parameter
-        U = self._heisenberg_rep(p)  # pylint: disable=assignment-from-none
+        U = self._heisenberg_rep(p)
 
         # not defined?
         if U is None:
@@ -2252,7 +2242,6 @@ class CVObservable(CV, Operator):
         """Avoids queuing the observable."""
         return self
 
-    # pylint: disable=abstract-method
     ev_order = None  #: None, int: Order in `(x, p)` that a CV observable is a polynomial of.
 
     def heisenberg_obs(self, wire_order):
@@ -2273,7 +2262,7 @@ class CVObservable(CV, Operator):
             array[float]: :math:`q`
         """
         p = self.parameters
-        U = self._heisenberg_rep(p)  # pylint: disable=assignment-from-none
+        U = self._heisenberg_rep(p)
         return self.heisenberg_expand(U, wire_order)
 
 
@@ -2282,7 +2271,6 @@ class StatePrepBase(Operation):
 
     grad_method = None
 
-    # pylint:disable=too-few-public-methods
     @abc.abstractmethod
     def state_vector(self, wire_order: Optional[WiresLike] = None) -> TensorLike:
         """
@@ -2426,7 +2414,7 @@ def has_unitary_gen(obj):
         PennyLaneDeprecationWarning,
     )
     # Linting check disabled as static analysis can misidentify qml.ops as the set instance qml.ops.qubit.ops
-    return obj in qml.ops.qubit.attributes.has_unitary_generator  # pylint:disable=no-member
+    return obj in qml.ops.qubit.attributes.has_unitary_generator
 
 
 @qml.BooleanFn
diff --git a/pennylane/ops/__init__.py b/pennylane/ops/__init__.py
index a35eb7e45..927c091d1 100644
--- a/pennylane/ops/__init__.py
+++ b/pennylane/ops/__init__.py
@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=too-few-public-methods,function-redefined
 
 """
 This module contains core quantum operations supported by PennyLane -
diff --git a/pennylane/ops/cv.py b/pennylane/ops/cv.py
index 0be58a5cd..3e2fe5d6c 100644
--- a/pennylane/ops/cv.py
+++ b/pennylane/ops/cv.py
@@ -35,7 +35,7 @@ quantum operations supported by PennyLane, as well as their conventions.
 """
 # As the qubit based ``decomposition``, ``_matrix``, ``diagonalizing_gates``
 # abstract methods are not defined in the CV case, disabling the related check
-# pylint: disable=abstract-method
+
 import math
 
 import numpy as np
@@ -73,7 +73,7 @@ def _rotation(phi, bare=False):
     temp = np.array([[c, -s], [s, c]])
     if bare:
         return temp
-    return block_diag(1, temp)  # pylint: disable=no-member
+    return block_diag(1, temp)
 
 
 class Rotation(CVOperation):
diff --git a/pennylane/ops/functions/assert_valid.py b/pennylane/ops/functions/assert_valid.py
index 0191f4cc4..74b84377f 100644
--- a/pennylane/ops/functions/assert_valid.py
+++ b/pennylane/ops/functions/assert_valid.py
@@ -363,7 +363,6 @@ def _check_pickle(op):
     assert unpickled == op, "operation must be able to be pickled and unpickled"
 
 
-# pylint: disable=no-member
 def _check_bind_new_parameters(op):
     """Check that bind new parameters can create a new op with different data."""
     new_data = [d * 0.0 for d in op.data]
diff --git a/pennylane/ops/functions/bind_new_parameters.py b/pennylane/ops/functions/bind_new_parameters.py
index fe33a1d35..65c22b663 100644
--- a/pennylane/ops/functions/bind_new_parameters.py
+++ b/pennylane/ops/functions/bind_new_parameters.py
@@ -154,7 +154,7 @@ def bind_new_parameters_composite_op(op: CompositeOp, params: Sequence[TensorLik
 @bind_new_parameters.register(qml.CNOT)
 @bind_new_parameters.register(qml.Toffoli)
 @bind_new_parameters.register(qml.MultiControlledX)
-def bind_new_parameters_copy(op, params: Sequence[TensorLike]):  # pylint:disable=unused-argument
+def bind_new_parameters_copy(op, params: Sequence[TensorLike]):
     return copy.copy(op)
 
 
diff --git a/pennylane/ops/functions/dot.py b/pennylane/ops/functions/dot.py
index 4b818c7ac..0076da108 100644
--- a/pennylane/ops/functions/dot.py
+++ b/pennylane/ops/functions/dot.py
@@ -15,7 +15,7 @@
 This file contains the definition of the dot function, which computes the dot product between
 a vector and a list of operators.
 """
-# pylint: disable=too-many-branches
+
 from collections import defaultdict
 from collections.abc import Callable, Sequence
 from typing import Union
diff --git a/pennylane/ops/functions/eigvals.py b/pennylane/ops/functions/eigvals.py
index 92af5b485..9153f3eaf 100644
--- a/pennylane/ops/functions/eigvals.py
+++ b/pennylane/ops/functions/eigvals.py
@@ -15,8 +15,6 @@
 This module contains the qml.eigvals function.
 """
 import warnings
-
-# pylint: disable=protected-access
 from functools import partial, reduce
 
 import scipy
diff --git a/pennylane/ops/functions/equal.py b/pennylane/ops/functions/equal.py
index 849959f7c..a6d79624e 100644
--- a/pennylane/ops/functions/equal.py
+++ b/pennylane/ops/functions/equal.py
@@ -15,6 +15,9 @@
 This module contains the qml.equal function.
 """
 # pylint: disable=too-many-arguments,too-many-return-statements,too-many-branches, too-many-positional-arguments
+
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=unused-argument
 from collections.abc import Iterable
 from functools import singledispatch
 from typing import Union
@@ -218,7 +221,7 @@ def _equal(
     check_trainability=True,
     rtol=1e-5,
     atol=1e-9,
-) -> Union[bool, str]:  # pylint: disable=unused-argument
+) -> Union[bool, str]:
     if not isinstance(op2, type(op1)):
         return f"op1 and op2 are of different types.  Got {type(op1)} and {type(op2)}."
 
@@ -240,7 +243,7 @@ def _equal_dispatch(
     check_trainability=True,
     rtol=1e-5,
     atol=1e-9,
-) -> Union[bool, str]:  # pylint: disable=unused-argument
+) -> Union[bool, str]:
     raise NotImplementedError(f"Comparison of {type(op1)} and {type(op2)} not implemented")
 
 
@@ -353,7 +356,6 @@ def _equal_operators(
     return True
 
 
-# pylint: disable=unused-argument
 @_equal_dispatch.register
 def _equal_pauliword(
     op1: PauliWord,
@@ -422,7 +424,7 @@ def _equal_paulisentence(
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument, protected-access
+# pylint: disable=protected-access
 def _equal_prod_and_sum(op1: CompositeOp, op2: CompositeOp, **kwargs):
     """Determine whether two Prod or Sum objects are equal"""
     if op1.pauli_rep is not None and (op1.pauli_rep == op2.pauli_rep):  # shortcut check
@@ -482,7 +484,6 @@ def _equal_controlled_sequence(op1: ControlledSequence, op2: ControlledSequence,
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _equal_pow(op1: Pow, op2: Pow, **kwargs):
     """Determine whether two Pow objects are equal"""
     check_interface, check_trainability = kwargs["check_interface"], kwargs["check_trainability"]
@@ -515,7 +516,6 @@ def _equal_pow(op1: Pow, op2: Pow, **kwargs):
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _equal_adjoint(op1: Adjoint, op2: Adjoint, **kwargs):
     """Determine whether two Adjoint objects are equal"""
     # first line of top-level equal function already confirms both are Adjoint - only need to compare bases
@@ -536,14 +536,12 @@ def _equal_conditional(op1: Conditional, op2: Conditional, **kwargs):
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _equal_measurement_value(op1: MeasurementValue, op2: MeasurementValue, **kwargs):
     """Determine whether two MeasurementValue objects are equal"""
     return op1.measurements == op2.measurements
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _equal_exp(op1: Exp, op2: Exp, **kwargs):
     """Determine whether two Exp objects are equal"""
     check_interface, check_trainability, rtol, atol = (
@@ -584,7 +582,6 @@ def _equal_exp(op1: Exp, op2: Exp, **kwargs):
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _equal_sprod(op1: SProd, op2: SProd, **kwargs):
     """Determine whether two SProd objects are equal"""
     check_interface, check_trainability, rtol, atol = (
@@ -650,7 +647,6 @@ def _equal_parametrized_evolution(op1: ParametrizedEvolution, op2: ParametrizedE
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _equal_measurements(
     op1: MeasurementProcess,
     op2: MeasurementProcess,
@@ -709,7 +705,6 @@ def _equal_mid_measure(op1: MidMeasureMP, op2: MidMeasureMP, **_):
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _(op1: VnEntropyMP, op2: VnEntropyMP, **kwargs):
     """Determine whether two MeasurementProcess objects are equal"""
     eq_m = _equal_measurements(op1, op2, **kwargs)
@@ -718,7 +713,6 @@ def _(op1: VnEntropyMP, op2: VnEntropyMP, **kwargs):
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _(op1: MutualInfoMP, op2: MutualInfoMP, **kwargs):
     """Determine whether two MeasurementProcess objects are equal"""
     eq_m = _equal_measurements(op1, op2, **kwargs)
@@ -727,7 +721,6 @@ def _(op1: MutualInfoMP, op2: MutualInfoMP, **kwargs):
 
 
 @_equal_dispatch.register
-# pylint: disable=unused-argument
 def _equal_shadow_measurements(op1: ShadowExpvalMP, op2: ShadowExpvalMP, **_):
     """Determine whether two ShadowExpvalMP objects are equal"""
 
@@ -794,9 +787,7 @@ def _equal_hilbert_schmidt(
 
 
 @_equal_dispatch.register
-def _equal_prep_sel_prep(
-    op1: PrepSelPrep, op2: PrepSelPrep, **kwargs
-):  # pylint: disable=unused-argument
+def _equal_prep_sel_prep(op1: PrepSelPrep, op2: PrepSelPrep, **kwargs):
     """Determine whether two PrepSelPrep are equal"""
     if op1.control != op2.control:
         return f"op1 and op2 have different control wires. Got {op1.control} and {op2.control}."
diff --git a/pennylane/ops/functions/generator.py b/pennylane/ops/functions/generator.py
index b54480fc9..9d15929ef 100644
--- a/pennylane/ops/functions/generator.py
+++ b/pennylane/ops/functions/generator.py
@@ -14,7 +14,7 @@
 """
 This module contains the qml.generator function.
 """
-# pylint: disable=protected-access
+
 import inspect
 import warnings
 
@@ -24,7 +24,6 @@ import pennylane as qml
 from pennylane.ops import LinearCombination, Prod, SProd, Sum
 
 
-# pylint: disable=too-many-branches
 def _generator_hamiltonian(gen, op):
     """Return the generator as type :class:`~ops.LinearCombination`."""
 
diff --git a/pennylane/ops/functions/is_commuting.py b/pennylane/ops/functions/is_commuting.py
index 4f01ccf72..5b82ce82e 100644
--- a/pennylane/ops/functions/is_commuting.py
+++ b/pennylane/ops/functions/is_commuting.py
@@ -73,7 +73,7 @@ def _get_target_name(op):
     }
     if op.name in _control_base_map:
         return _control_base_map[op.name]
-    if isinstance(op, qml.ops.op_math.Controlled):  # pylint: disable=no-member
+    if isinstance(op, qml.ops.op_math.Controlled):
         return op.base.name
     return op.name
 
@@ -336,7 +336,7 @@ def is_commuting(operation1, operation2):
     >>> qml.is_commuting(qml.X(0), qml.Z(0))
     False
     """
-    # pylint: disable=too-many-branches
+
     # pylint: disable=too-many-return-statements
 
     if operation1.name in unsupported_operations or isinstance(
diff --git a/pennylane/ops/functions/matrix.py b/pennylane/ops/functions/matrix.py
index 62798ae21..c2cecf46c 100644
--- a/pennylane/ops/functions/matrix.py
+++ b/pennylane/ops/functions/matrix.py
@@ -16,7 +16,7 @@ This module contains the qml.matrix function.
 """
 from functools import partial
 
-# pylint: disable=protected-access,too-many-branches
+# pylint: disable=too-many-branches
 from typing import Union
 
 import pennylane as qml
diff --git a/pennylane/ops/identity.py b/pennylane/ops/identity.py
index b45aecefe..d8cef5b76 100644
--- a/pennylane/ops/identity.py
+++ b/pennylane/ops/identity.py
@@ -212,7 +212,6 @@ class Identity(CVObservable, Operation):
     def adjoint(self):
         return I(wires=self.wires)
 
-    # pylint: disable=unused-argument
     def pow(self, z):
         return [I(wires=self.wires)]
 
diff --git a/pennylane/ops/meta.py b/pennylane/ops/meta.py
index dd3519c15..11502cf2e 100644
--- a/pennylane/ops/meta.py
+++ b/pennylane/ops/meta.py
@@ -17,7 +17,7 @@ not depend on any parameters.
 """
 from collections.abc import Hashable
 
-# pylint:disable=abstract-method,arguments-differ,protected-access,invalid-overridden-method, no-member
+# pylint: disable=arguments-differ
 from copy import copy
 from typing import Literal, Optional, Sequence, Union
 
@@ -124,8 +124,10 @@ class WireCut(Operation):
                 f"{self.name}: wrong number of wires. At least one wire has to be provided."
             )
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=unused-argument
     @staticmethod
-    def compute_decomposition(wires: WiresLike):  # pylint: disable=unused-argument
+    def compute_decomposition(wires: WiresLike):
         r"""Representation of the operator as a product of other operators (static method).
 
         Since this operator is a placeholder inside a circuit, it decomposes into an empty list.
diff --git a/pennylane/ops/op_math/adjoint.py b/pennylane/ops/op_math/adjoint.py
index 32f79a712..f0eead95b 100644
--- a/pennylane/ops/op_math/adjoint.py
+++ b/pennylane/ops/op_math/adjoint.py
@@ -269,7 +269,6 @@ def _single_op_eager(op: Operator, update_queue: bool = False) -> Operator:
     return Adjoint(op)
 
 
-# pylint: disable=too-many-public-methods
 class Adjoint(SymbolicOp):
     """
     The Adjoint of an operator.
@@ -333,6 +332,7 @@ class Adjoint(SymbolicOp):
     def _unflatten(cls, data, _):
         return cls(data[0])
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
     # pylint: disable=unused-argument
     def __new__(cls, base=None, id=None):
         """Returns an uninitialized type with the necessary mixins.
@@ -392,7 +392,6 @@ class Adjoint(SymbolicOp):
     def has_sparse_matrix(self) -> bool:
         return self.base.has_sparse_matrix
 
-    # pylint: disable=arguments-differ
     def sparse_matrix(self, wire_order=None, format="csr"):
         base_matrix = self.base.sparse_matrix(wire_order=wire_order)
         return transpose(conj(base_matrix)).asformat(format=format)
@@ -435,7 +434,6 @@ class Adjoint(SymbolicOp):
         return Adjoint(base=base)
 
 
-# pylint: disable=no-member
 class AdjointOperation(Adjoint, Operation):
     """This mixin class is dynamically added to an ``Adjoint`` instance if the provided base class
     is an ``Operation``.
@@ -457,7 +455,6 @@ class AdjointOperation(Adjoint, Operation):
     def name(self):
         return self._name
 
-    # pylint: disable=missing-function-docstring
     @property
     def basis(self):
         return self.base.basis
@@ -499,6 +496,7 @@ class AdjointObs(Adjoint, Observable):
         return object.__new__(cls)
 
 
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
 # pylint: disable=too-many-ancestors
 class AdjointOpObs(AdjointOperation, Observable):
     """A child of :class:`~.AdjointOperation` that also inherits from :class:`~.Observable."""
diff --git a/pennylane/ops/op_math/composite.py b/pennylane/ops/op_math/composite.py
index 1cdfdb379..4276eb2f2 100644
--- a/pennylane/ops/op_math/composite.py
+++ b/pennylane/ops/op_math/composite.py
@@ -14,7 +14,7 @@
 """
 This submodule defines a base class for composite operations.
 """
-# pylint: disable=too-many-instance-attributes,invalid-sequence-index
+# pylint: disable=invalid-sequence-index
 import abc
 import copy
 from collections.abc import Callable
diff --git a/pennylane/ops/op_math/condition.py b/pennylane/ops/op_math/condition.py
index 4e80e5cc0..90592bef8 100644
--- a/pennylane/ops/op_math/condition.py
+++ b/pennylane/ops/op_math/condition.py
@@ -138,7 +138,7 @@ class Conditional(SymbolicOp, Operation):
         return Conditional(self.meas_val, self.base.adjoint())
 
 
-class CondCallable:  # pylint:disable=too-few-public-methods
+class CondCallable:
     """Base class to represent a conditional function with boolean predicates.
 
     Args:
@@ -246,8 +246,9 @@ class CondCallable:  # pylint:disable=too-few-public-methods
         for pred, branch_fn in zip(self.preds, self.branch_fns):
             if pred:
                 return branch_fn(*args, **kwargs)
-
-        return self.false_fn(*args, **kwargs)  # pylint: disable=not-callable
+        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+        # pylint: disable=not-callable
+        return self.false_fn(*args, **kwargs)
 
     def __call_capture_enabled(self, *args, **kwargs):
         import jax  # pylint: disable=import-outside-toplevel
diff --git a/pennylane/ops/op_math/controlled.py b/pennylane/ops/op_math/controlled.py
index fd5298b98..34aeec3ab 100644
--- a/pennylane/ops/op_math/controlled.py
+++ b/pennylane/ops/op_math/controlled.py
@@ -490,7 +490,7 @@ class Controlled(SymbolicOp):
             base, *control_wires, control_values=control_values, work_wires=work_wires
         )
 
-    # pylint: disable=too-many-function-args, too-many-positional-arguments
+    # pylint: disable=too-many-positional-arguments
     def __init__(
         self,
         base,
@@ -685,7 +685,6 @@ class Controlled(SymbolicOp):
     def has_sparse_matrix(self):
         return self.base.has_sparse_matrix or self.base.has_matrix
 
-    # pylint: disable=arguments-differ
     def sparse_matrix(self, wire_order=None, format="csr"):
         try:
             target_mat = self.base.sparse_matrix()
@@ -937,7 +936,7 @@ class ControlledOp(Controlled, operation.Operation):
         # overrides dispatch behaviour of ``Controlled``
         return object.__new__(cls)
 
-    # pylint: disable=too-many-function-args, too-many-positional-arguments
+    # pylint: disable=too-many-positional-arguments
     def __init__(self, base, control_wires, control_values=None, work_wires=None, id=None):
         super().__init__(base, control_wires, control_values, work_wires, id)
         # check the grad_recipe validity
diff --git a/pennylane/ops/op_math/controlled_ops.py b/pennylane/ops/op_math/controlled_ops.py
index b51ba8e24..1f3a25ef5 100644
--- a/pennylane/ops/op_math/controlled_ops.py
+++ b/pennylane/ops/op_math/controlled_ops.py
@@ -14,7 +14,7 @@
 """
 This submodule contains controlled operators based on the ControlledOp class.
 """
-# pylint: disable=no-value-for-parameter, arguments-differ, arguments-renamed
+# pylint: disable=arguments-differ,arguments-renamed
 from collections.abc import Iterable
 from functools import lru_cache
 from typing import List, Literal, Union
@@ -40,7 +40,6 @@ from .controlled_decompositions import decompose_mcx
 INV_SQRT2 = 1 / qml.math.sqrt(2)
 
 
-# pylint: disable=too-few-public-methods
 class ControlledQubitUnitary(ControlledOp):
     r"""ControlledQubitUnitary(U, wires)
     Apply an arbitrary fixed unitary matrix ``U`` to ``wires``. If ``n = len(wires) `` and ``U`` has ``k`` wires, then the first ``n - k`` from ``wires`` serve as control, and ``U`` lives on the last ``k`` wires.
@@ -122,7 +121,7 @@ class ControlledQubitUnitary(ControlledOp):
     def _unflatten(cls, data, metadata):
         return cls(data[0], wires=metadata[0], control_values=metadata[1], work_wires=metadata[2])
 
-    # pylint: disable=arguments-differ, too-many-arguments, unused-argument, too-many-positional-arguments
+    # pylint: disable=too-many-arguments,unused-argument,too-many-positional-arguments
     @classmethod
     def _primitive_bind_call(
         cls,
@@ -857,7 +856,7 @@ class CCZ(ControlledOp):
     @staticmethod
     def compute_decomposition(
         wires: WiresLike,
-    ) -> List[qml.operation.Operator]:  # pylint: disable=arguments-differ
+    ) -> List[qml.operation.Operator]:
         r"""Representation of the operator as a product of other operators (static method).
 
         .. math:: O = O_1 O_2 \dots O_n.
@@ -1186,7 +1185,7 @@ class Toffoli(ControlledOp):
     @staticmethod
     def compute_decomposition(
         wires: WiresLike,
-    ) -> List[qml.operation.Operator]:  # pylint: disable=arguments-differ
+    ) -> List[qml.operation.Operator]:
         r"""Representation of the operator as a product of other operators (static method).
 
         .. math:: O = O_1 O_2 \dots O_n.
@@ -1362,7 +1361,10 @@ class MultiControlledX(ControlledOp):
             work_wire_type=metadata[3],
         )
 
-    # pylint: disable=arguments-differ, too-many-arguments, too-many-positional-arguments
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=arguments-differ
     @classmethod
     def _primitive_bind_call(
         cls, wires, control_values=None, work_wires=None, work_wire_type="clean", id=None
@@ -1389,7 +1391,6 @@ class MultiControlledX(ControlledOp):
             ):
                 raise ValueError(f"control_values must be boolean or int. Got: {control_values}")
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         wires: WiresLike = (),
@@ -1697,9 +1698,7 @@ class CRX(ControlledOp):
         return qml.math.stack([stack_last(row) for row in matrix], axis=-2)
 
     @staticmethod
-    def compute_decomposition(
-        phi: TensorLike, wires: WiresLike
-    ) -> List[qml.operation.Operator]:  # pylint: disable=arguments-differ
+    def compute_decomposition(phi: TensorLike, wires: WiresLike) -> List[qml.operation.Operator]:
         r"""Representation of the operator as a product of other operators (static method). :
 
         .. math:: O = O_1 O_2 \dots O_n.
@@ -1906,9 +1905,7 @@ class CRY(ControlledOp):
         return qml.math.stack([stack_last(row) for row in matrix], axis=-2)
 
     @staticmethod
-    def compute_decomposition(
-        phi: TensorLike, wires: WiresLike
-    ) -> List[qml.operation.Operator]:  # pylint: disable=arguments-differ
+    def compute_decomposition(phi: TensorLike, wires: WiresLike) -> List[qml.operation.Operator]:
         r"""Representation of the operator as a product of other operators (static method). :
 
         .. math:: O = O_1 O_2 \dots O_n.
@@ -2126,9 +2123,7 @@ class CRZ(ControlledOp):
         return self.compute_eigvals(*self.parameters)
 
     @staticmethod
-    def compute_decomposition(
-        phi: TensorLike, wires: WiresLike
-    ) -> List[qml.operation.Operator]:  # pylint: disable=arguments-differ
+    def compute_decomposition(phi: TensorLike, wires: WiresLike) -> List[qml.operation.Operator]:
         r"""Representation of the operator as a product of other operators (static method). :
 
         .. math:: O = O_1 O_2 \dots O_n.
@@ -2335,7 +2330,7 @@ class CRot(ControlledOp):
     @staticmethod
     def compute_decomposition(
         phi: TensorLike, theta: TensorLike, omega: TensorLike, wires: WiresLike
-    ) -> List[qml.operation.Operator]:  # pylint: disable=arguments-differ
+    ) -> List[qml.operation.Operator]:
         r"""Representation of the operator as a product of other operators (static method). :
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/ops/op_math/evolution.py b/pennylane/ops/op_math/evolution.py
index 298e27e5c..f53ed6489 100644
--- a/pennylane/ops/op_math/evolution.py
+++ b/pennylane/ops/op_math/evolution.py
@@ -77,7 +77,6 @@ class Evolution(Exp):
     _name = "Evolution"
     num_params = 1
 
-    # pylint: disable=too-many-arguments
     def __init__(self, generator, param=1, num_steps=None, id=None):
         super().__init__(generator, coeff=-1j * param, num_steps=num_steps, id=id)
         self._data = (param,)
@@ -116,11 +115,10 @@ class Evolution(Exp):
 
     def simplify(self):
         new_base = self.base.simplify()
-        if isinstance(new_base, qml.ops.op_math.SProd):  # pylint: disable=no-member
+        if isinstance(new_base, qml.ops.op_math.SProd):
             return Evolution(new_base.base, self.param * new_base.scalar)
         return Evolution(new_base, self.param)
 
-    # pylint: disable=arguments-renamed, invalid-overridden-method
     @property
     def has_generator(self):
         return not qml.math.real(self.coeff)
diff --git a/pennylane/ops/op_math/exp.py b/pennylane/ops/op_math/exp.py
index 4b1a7e8ef..2371acbe0 100644
--- a/pennylane/ops/op_math/exp.py
+++ b/pennylane/ops/op_math/exp.py
@@ -171,7 +171,6 @@ class Exp(ScalarSymbolicOp, Operation):
     def _unflatten(cls, data, metadata):
         return cls(data[0], data[1], num_steps=metadata[0])
 
-    # pylint: disable=too-many-arguments
     def __init__(self, base, coeff=1, num_steps=None, id=None):
         if not isinstance(base, Operator):
             raise TypeError(f"base is expected to be of type Operator, but received {type(base)}")
@@ -293,8 +292,8 @@ class Exp(ScalarSymbolicOp, Operation):
         # Store operator classes with generators
         has_generator_types = []
         has_generator_types_anywires = []
-        for op_name in qml.ops.qubit.__all__:  # pylint:disable=no-member
-            op_class = getattr(qml.ops.qubit, op_name)  # pylint:disable=no-member
+        for op_name in qml.ops.qubit.__all__:
+            op_class = getattr(qml.ops.qubit, op_name)
             if op_class.has_generator:
                 if op_class.num_wires is None:
                     has_generator_types_anywires.append(op_class)
@@ -413,7 +412,6 @@ class Exp(ScalarSymbolicOp, Operation):
     def _matrix(scalar, mat):
         return math.expm(scalar * mat)
 
-    # pylint: disable=arguments-differ
     def sparse_matrix(self, wire_order=None, format="csr"):
         if wire_order is not None:
             raise NotImplementedError("Wire order is not implemented for sparse_matrix")
@@ -462,7 +460,7 @@ class Exp(ScalarSymbolicOp, Operation):
 
     def simplify(self):
         new_base = self.base.simplify()
-        if isinstance(new_base, qml.ops.op_math.SProd):  # pylint: disable=no-member
+        if isinstance(new_base, qml.ops.op_math.SProd):
             return Exp(new_base.base, self.coeff * new_base.scalar, self.num_steps)
         return Exp(new_base, self.coeff, self.num_steps)
 
diff --git a/pennylane/ops/op_math/linear_combination.py b/pennylane/ops/op_math/linear_combination.py
index 24d0fcf9f..62df12f7e 100644
--- a/pennylane/ops/op_math/linear_combination.py
+++ b/pennylane/ops/op_math/linear_combination.py
@@ -18,7 +18,7 @@ import itertools
 import numbers
 import warnings
 
-# pylint: disable=too-many-arguments, protected-access, too-many-instance-attributes
+# pylint: disable=too-many-arguments,protected-access
 from copy import copy
 from typing import Union
 
diff --git a/pennylane/ops/op_math/pow.py b/pennylane/ops/op_math/pow.py
index 08b06887d..5f8c1fd0d 100644
--- a/pennylane/ops/op_math/pow.py
+++ b/pennylane/ops/op_math/pow.py
@@ -140,6 +140,7 @@ class Pow(ScalarSymbolicOp):
     def _unflatten(cls, data, _):
         return pow(data[0], z=data[1])
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
     # pylint: disable=unused-argument
     def __new__(cls, base=None, z=1, id=None):
         """Mixes in parents based on inheritance structure of base.
@@ -406,7 +407,6 @@ class Pow(ScalarSymbolicOp):
             return Pow(base=base, z=self.z)
 
 
-# pylint: disable=no-member
 class PowOperation(Pow, Operation):
     """Operation-specific methods and properties for the ``Pow`` class.
 
diff --git a/pennylane/ops/op_math/sum.py b/pennylane/ops/op_math/sum.py
index 21bc2f9cd..da898e474 100644
--- a/pennylane/ops/op_math/sum.py
+++ b/pennylane/ops/op_math/sum.py
@@ -15,7 +15,7 @@
 This file contains the implementation of the Sum class which contains logic for
 computing the sum of operations.
 """
-# pylint: disable=too-many-arguments,too-many-instance-attributes,protected-access
+
 
 import itertools
 from collections import Counter
@@ -425,8 +425,10 @@ class Sum(CompositeOp):
 
         return new_summands
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=arguments-differ
     @handle_recursion_error
-    def simplify(self, cutoff=1.0e-12) -> "Sum":  # pylint: disable=arguments-differ
+    def simplify(self, cutoff=1.0e-12) -> "Sum":
         # try using pauli_rep:
         if pr := self.pauli_rep:
             pr.simplify()
@@ -587,7 +589,7 @@ class _SumSummandsGrouping:
             coeff (int, optional): Coefficient of the operator. Defaults to 1.
             op_hash (int, optional): Hash of the operator. Defaults to None.
         """
-        if isinstance(summand, qml.ops.SProd):  # pylint: disable=no-member
+        if isinstance(summand, qml.ops.SProd):
             coeff = summand.scalar if coeff == 1 else summand.scalar * coeff
             self.add(summand=summand.base, coeff=coeff)
         else:
diff --git a/pennylane/ops/op_math/symbolicop.py b/pennylane/ops/op_math/symbolicop.py
index 5d8ea2a0b..e87ef4516 100644
--- a/pennylane/ops/op_math/symbolicop.py
+++ b/pennylane/ops/op_math/symbolicop.py
@@ -54,7 +54,6 @@ class SymbolicOp(Operator):
         # has no wires, so doesn't need any wires processing
         return cls._primitive.bind(*args, **kwargs)
 
-    # pylint: disable=attribute-defined-outside-init
     @handle_recursion_error
     def __copy__(self):
         # this method needs to be overwritten because the base must be copied too.
diff --git a/pennylane/ops/qubit/arithmetic_ops.py b/pennylane/ops/qubit/arithmetic_ops.py
index 635394640..e96e1e2ce 100644
--- a/pennylane/ops/qubit/arithmetic_ops.py
+++ b/pennylane/ops/qubit/arithmetic_ops.py
@@ -15,7 +15,7 @@
 This submodule contains the discrete-variable quantum operations that perform
 arithmetic operations on their input states.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access
+# pylint: disable=arguments-differ
 from copy import copy
 from typing import Optional
 
@@ -418,7 +418,6 @@ class IntegerComparator(Operation):
         )
         return tuple(), (hp["control_wires"] + hp["target_wires"], metadata)
 
-    # pylint: disable=too-many-arguments
     def __init__(
         self,
         value: int,
@@ -469,7 +468,7 @@ class IntegerComparator(Operation):
     @staticmethod
     def compute_matrix(
         control_wires: WiresLike, value: Optional[int] = None, geq: bool = True, **kwargs
-    ) -> TensorLike:  # pylint: disable=arguments-differ
+    ) -> TensorLike:
         r"""Representation of the operator as a canonical matrix in the computational basis (static method).
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
diff --git a/pennylane/ops/qubit/matrix_ops.py b/pennylane/ops/qubit/matrix_ops.py
index 5e137d582..f6e2cf7ea 100644
--- a/pennylane/ops/qubit/matrix_ops.py
+++ b/pennylane/ops/qubit/matrix_ops.py
@@ -142,7 +142,7 @@ class QubitUnitary(Operation):
         wires: WiresLike,
         id: Optional[str] = None,
         unitary_check: bool = False,
-    ):  # pylint: disable=too-many-arguments
+    ):
         wires = Wires(wires)
         U_shape = qml.math.shape(U)
         dim = 2 ** len(wires)
diff --git a/pennylane/ops/qubit/non_parametric_ops.py b/pennylane/ops/qubit/non_parametric_ops.py
index 563706ddd..857dbae11 100644
--- a/pennylane/ops/qubit/non_parametric_ops.py
+++ b/pennylane/ops/qubit/non_parametric_ops.py
@@ -15,7 +15,7 @@
 This submodule contains the discrete-variable quantum operations that do
 not depend on any parameters.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access,invalid-overridden-method, no-member
+# pylint: disable=arguments-differ
 import cmath
 from copy import copy
 from functools import lru_cache
@@ -827,8 +827,10 @@ class PauliZ(Observable, Operation):
         """
         return qml.pauli.pauli_eigs(1)
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=unused-argument
     @staticmethod
-    def compute_diagonalizing_gates(  # pylint: disable=unused-argument
+    def compute_diagonalizing_gates(
         wires: WiresLike,
     ) -> list[qml.operation.Operator]:
         r"""Sequence of gates that diagonalize the operator in the computational basis (static method).
diff --git a/pennylane/ops/qubit/observables.py b/pennylane/ops/qubit/observables.py
index 2626aa75a..4cb980bcb 100644
--- a/pennylane/ops/qubit/observables.py
+++ b/pennylane/ops/qubit/observables.py
@@ -137,7 +137,7 @@ class Hermitian(Observable):
         Hermitian._validate_input(A)
         return A
 
-    # pylint: disable=arguments-differ, unused-argument
+    # pylint: disable=arguments-differ
     @staticmethod
     def compute_sparse_matrix(A, format="csr") -> csr_matrix:
         return csr_matrix(Hermitian.compute_matrix(A)).asformat(format)
@@ -368,7 +368,9 @@ class SparseHamiltonian(Observable):
         """
         return H.toarray()
 
-    # pylint: disable=arguments-differ, unused-argument
+    # pylint: disable=arguments-differ
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=unused-argument
     @staticmethod
     def compute_sparse_matrix(H: spmatrix, format="csr") -> spmatrix:
         r"""Representation of the operator as a sparse canonical matrix in the computational basis (static method).
@@ -523,7 +525,7 @@ class BasisStateProjector(Projector, Operation):
 
         super().__init__(state, wires=wires, id=id)
 
-    def __new__(cls, *_, **__):  # pylint: disable=arguments-differ
+    def __new__(cls, *_, **__):
         return object.__new__(cls)
 
     def label(
@@ -693,7 +695,7 @@ class StateVectorProjector(Projector):
         wires = Wires(wires)
         super().__init__(state, wires=wires, id=id)
 
-    def __new__(cls, *_, **__):  # pylint: disable=arguments-differ
+    def __new__(cls, *_, **__):
         return object.__new__(cls)
 
     # pylint: disable=unused-argument
@@ -753,7 +755,7 @@ class StateVectorProjector(Projector):
         return f"P(M{mat_num})"
 
     @staticmethod
-    def compute_matrix(  # pylint: disable=arguments-differ,arguments-renamed
+    def compute_matrix(  # pylint: disable=arguments-differ
         state_vector: TensorLike,
     ) -> np.ndarray:
         r"""Representation of the operator as a canonical matrix in the computational basis (static method).
@@ -782,7 +784,7 @@ class StateVectorProjector(Projector):
         return qml.math.outer(state_vector, qml.math.conj(state_vector))
 
     @staticmethod
-    def compute_eigvals(  # pylint: disable=arguments-differ,arguments-renamed
+    def compute_eigvals(  # pylint: disable=arguments-differ
         state_vector: TensorLike,
     ) -> np.ndarray:
         r"""Eigenvalues of the operator in the computational basis (static method).
@@ -816,7 +818,7 @@ class StateVectorProjector(Projector):
         return qml.math.convert_like(w, state_vector)
 
     @staticmethod
-    def compute_diagonalizing_gates(  # pylint: disable=arguments-differ,unused-argument,arguments-renamed
+    def compute_diagonalizing_gates(  # pylint: disable=arguments-differ
         state_vector: TensorLike, wires: WiresLike
     ) -> list["qml.operation.Operator"]:
         r"""Sequence of gates that diagonalize the operator in the computational basis (static method).
diff --git a/pennylane/ops/qubit/parametric_ops_multi_qubit.py b/pennylane/ops/qubit/parametric_ops_multi_qubit.py
index 6b2c770cd..83819b6af 100644
--- a/pennylane/ops/qubit/parametric_ops_multi_qubit.py
+++ b/pennylane/ops/qubit/parametric_ops_multi_qubit.py
@@ -11,12 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=too-many-arguments
+
 """
 This submodule contains the discrete-variable quantum operations that are the
 core parametrized gates.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access,invalid-overridden-method
+# pylint: disable=arguments-differ
 import functools
 from operator import matmul
 from typing import Optional, Union
@@ -87,9 +87,7 @@ class MultiRZ(Operation):
             )
 
     @staticmethod
-    def compute_matrix(
-        theta: TensorLike, num_wires: int
-    ) -> TensorLike:  # pylint: disable=arguments-differ
+    def compute_matrix(theta: TensorLike, num_wires: int) -> TensorLike:
         r"""Representation of the operator as a canonical matrix in the computational basis (static method).
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
@@ -130,9 +128,7 @@ class MultiRZ(Operation):
         return qml.Hamiltonian([-0.5], [functools.reduce(matmul, [PauliZ(w) for w in self.wires])])
 
     @staticmethod
-    def compute_eigvals(
-        theta: TensorLike, num_wires: int
-    ) -> TensorLike:  # pylint: disable=arguments-differ
+    def compute_eigvals(theta: TensorLike, num_wires: int) -> TensorLike:
         r"""Eigenvalues of the operator in the computational basis (static method).
 
         If :attr:`diagonalizing_gates` are specified and implement a unitary :math:`U^{\dagger}`,
@@ -399,9 +395,7 @@ class PauliRot(Operation):
         return all(pauli in PauliRot._ALLOWED_CHARACTERS for pauli in set(pauli_word))
 
     @staticmethod
-    def compute_matrix(
-        theta: TensorLike, pauli_word: str
-    ) -> TensorLike:  # pylint: disable=arguments-differ
+    def compute_matrix(theta: TensorLike, pauli_word: str) -> TensorLike:
         r"""Representation of the operator as a canonical matrix in the computational basis (static method).
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
@@ -474,9 +468,7 @@ class PauliRot(Operation):
         )
 
     @staticmethod
-    def compute_eigvals(
-        theta: TensorLike, pauli_word: str
-    ) -> TensorLike:  # pylint: disable=arguments-differ
+    def compute_eigvals(theta: TensorLike, pauli_word: str) -> TensorLike:
         r"""Eigenvalues of the operator in the computational basis (static method).
 
         If :attr:`diagonalizing_gates` are specified and implement a unitary :math:`U^{\dagger}`,
diff --git a/pennylane/ops/qubit/parametric_ops_single_qubit.py b/pennylane/ops/qubit/parametric_ops_single_qubit.py
index 0a5b8086d..ea84fe451 100644
--- a/pennylane/ops/qubit/parametric_ops_single_qubit.py
+++ b/pennylane/ops/qubit/parametric_ops_single_qubit.py
@@ -16,7 +16,7 @@
 This submodule contains the discrete-variable quantum operations that are the
 core parametrized gates.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access,invalid-overridden-method
+# pylint: disable=arguments-differ
 import functools
 from typing import Optional, Union
 
@@ -745,7 +745,7 @@ class Rot(Operation):
         phi: TensorLike,
         theta: TensorLike,
         omega: TensorLike,
-    ) -> TensorLike:  # pylint: disable=arguments-differ
+    ) -> TensorLike:
         r"""Representation of the operator as a canonical matrix in the computational basis (static method).
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
@@ -1088,9 +1088,7 @@ class U2(Operation):
         return {}
 
     @staticmethod
-    def compute_matrix(
-        phi: TensorLike, delta: TensorLike
-    ) -> TensorLike:  # pylint: disable=arguments-differ
+    def compute_matrix(phi: TensorLike, delta: TensorLike) -> TensorLike:
         r"""Representation of the operator as a canonical matrix in the computational basis (static method).
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
@@ -1272,9 +1270,7 @@ class U3(Operation):
         return {}
 
     @staticmethod
-    def compute_matrix(
-        theta: TensorLike, phi: TensorLike, delta: TensorLike
-    ) -> TensorLike:  # pylint: disable=arguments-differ
+    def compute_matrix(theta: TensorLike, phi: TensorLike, delta: TensorLike) -> TensorLike:
         r"""Representation of the operator as a canonical matrix in the computational basis (static method).
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
diff --git a/pennylane/ops/qubit/qchem_ops.py b/pennylane/ops/qubit/qchem_ops.py
index 3789c6030..4e9afe2c8 100644
--- a/pennylane/ops/qubit/qchem_ops.py
+++ b/pennylane/ops/qubit/qchem_ops.py
@@ -15,7 +15,7 @@
 This submodule contains the discrete-variable quantum operations that come
 from quantum chemistry applications.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access
+# pylint: disable=arguments-differ
 import functools
 from typing import Optional, Union
 
diff --git a/pennylane/ops/qubit/state_preparation.py b/pennylane/ops/qubit/state_preparation.py
index d0268afb2..0ef370eed 100644
--- a/pennylane/ops/qubit/state_preparation.py
+++ b/pennylane/ops/qubit/state_preparation.py
@@ -15,7 +15,7 @@
 This submodule contains the discrete-variable quantum operations concerned
 with preparing a certain state on the device.
 """
-# pylint:disable=too-many-branches,abstract-method,arguments-differ,protected-access,no-member
+# pylint: disable=too-many-branches,arguments-differ
 from typing import Optional, Union
 from warnings import warn
 
diff --git a/pennylane/ops/qutrit/matrix_ops.py b/pennylane/ops/qutrit/matrix_ops.py
index e73561431..edd1efa4a 100644
--- a/pennylane/ops/qutrit/matrix_ops.py
+++ b/pennylane/ops/qutrit/matrix_ops.py
@@ -15,7 +15,7 @@
 This submodule contains the qutrit quantum operations that
 accept a unitary matrix as a parameter.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access
+
 import warnings
 
 import pennylane as qml
diff --git a/pennylane/ops/qutrit/observables.py b/pennylane/ops/qutrit/observables.py
index 381c7055f..d69f2cbc5 100644
--- a/pennylane/ops/qutrit/observables.py
+++ b/pennylane/ops/qutrit/observables.py
@@ -16,7 +16,7 @@ This submodule contains the qutrit quantum observables.
 """
 import numpy as np
 
-import pennylane as qml  # pylint: disable=unused-import
+import pennylane as qml
 from pennylane._deprecated_observable import Observable
 from pennylane.ops.qubit import Hermitian
 from pennylane.ops.qutrit import QutritUnitary
@@ -119,7 +119,7 @@ class THermitian(Hermitian):
         return THermitian._eigs[Hkey]
 
     @staticmethod
-    def compute_diagonalizing_gates(eigenvectors, wires):  # pylint: disable=arguments-differ
+    def compute_diagonalizing_gates(eigenvectors, wires):
         r"""Sequence of gates that diagonalize the operator in the computational basis (static method).
 
         Given the eigendecomposition :math:`O = U \Sigma U^{\dagger}` where
@@ -319,9 +319,7 @@ class GellMann(Observable):
         return np.array([1, 1, -2]) / np.sqrt(3)
 
     @staticmethod
-    def compute_diagonalizing_gates(
-        wires, index
-    ):  # pylint: disable=arguments-differ,unused-argument
+    def compute_diagonalizing_gates(wires, index):  # pylint: disable=arguments-differ
         r"""Sequence of gates that diagonalize the operator in the computational basis (static method).
 
         Given the eigendecomposition :math:`O = U \Sigma U^{\dagger}` where
diff --git a/pennylane/ops/qutrit/parametric_ops.py b/pennylane/ops/qutrit/parametric_ops.py
index 119ebde5a..b13a99363 100644
--- a/pennylane/ops/qutrit/parametric_ops.py
+++ b/pennylane/ops/qutrit/parametric_ops.py
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# pylint: disable=too-many-arguments
+
 """
 This submodule contains the discrete-variable quantum operations that are the
 core parametrized gates for qutrits.
@@ -138,9 +138,7 @@ class TRX(Operation):
         return self._subspace
 
     @staticmethod
-    def compute_matrix(
-        theta, subspace=(0, 1)
-    ):  # pylint: disable=arguments-differ,dangerous-default-value
+    def compute_matrix(theta, subspace=(0, 1)):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a canonical matrix in the computational basis.
 
         The canonical matrix is the textbook matrix representation that does not consider wires.
diff --git a/pennylane/ops/qutrit/state_preparation.py b/pennylane/ops/qutrit/state_preparation.py
index 0046b1628..82cccb5e1 100644
--- a/pennylane/ops/qutrit/state_preparation.py
+++ b/pennylane/ops/qutrit/state_preparation.py
@@ -15,7 +15,7 @@
 This submodule contains the discrete-variable quantum operations concerned
 with preparing a certain state on the qutrit device.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access,no-member
+# pylint: disable=arguments-differ
 import numpy as np
 
 from pennylane import math
diff --git a/pennylane/optimize/adaptive.py b/pennylane/optimize/adaptive.py
index 8edca18f2..cd69a534b 100644
--- a/pennylane/optimize/adaptive.py
+++ b/pennylane/optimize/adaptive.py
@@ -14,7 +14,7 @@
 """Adaptive optimizer"""
 import copy
 
-# pylint: disable= no-value-for-parameter, protected-access, not-callable
+# pylint: disable=not-callable
 from pennylane import math
 from pennylane import numpy as pnp
 from pennylane._grad import grad
diff --git a/pennylane/optimize/momentum_qng.py b/pennylane/optimize/momentum_qng.py
index 376b18d60..caaf7b2ed 100644
--- a/pennylane/optimize/momentum_qng.py
+++ b/pennylane/optimize/momentum_qng.py
@@ -13,8 +13,7 @@
 # limitations under the License.
 """Quantum natural gradient optimizer with momentum"""
 
-# pylint: disable=too-many-branches
-# pylint: disable=too-many-arguments
+
 from pennylane import numpy as pnp
 
 from .qng import QNGOptimizer, _flatten_np, _unflatten_np
diff --git a/pennylane/optimize/qng.py b/pennylane/optimize/qng.py
index e01463881..818045689 100644
--- a/pennylane/optimize/qng.py
+++ b/pennylane/optimize/qng.py
@@ -15,8 +15,6 @@
 import numbers
 from collections.abc import Iterable
 
-# pylint: disable=too-many-branches
-# pylint: disable=too-many-arguments
 from pennylane import math
 from pennylane import numpy as pnp
 from pennylane.gradients.metric_tensor import metric_tensor
diff --git a/pennylane/optimize/riemannian_gradient.py b/pennylane/optimize/riemannian_gradient.py
index 76892f3d2..d3e95279f 100644
--- a/pennylane/optimize/riemannian_gradient.py
+++ b/pennylane/optimize/riemannian_gradient.py
@@ -276,7 +276,6 @@ class RiemannianGradientOptimizer:
             tuple[.QNode, float]: the optimized circuit and the objective function output prior
             to the step.
         """
-        # pylint: disable=not-callable
 
         cost = self.circuit()
         omegas = self.get_omegas()
diff --git a/pennylane/optimize/rotoselect.py b/pennylane/optimize/rotoselect.py
index e4aaba037..b6ec04c9f 100644
--- a/pennylane/optimize/rotoselect.py
+++ b/pennylane/optimize/rotoselect.py
@@ -90,8 +90,6 @@ class RotoselectOptimizer:
     the circuit, while steps-vs-cost can be seen by plotting ``cost_rotosel``.
     """
 
-    # pylint: disable=too-few-public-methods
-
     def __init__(self, possible_generators=None):
         self.possible_generators = possible_generators or [RX, RY, RZ]
 
diff --git a/pennylane/optimize/rotosolve.py b/pennylane/optimize/rotosolve.py
index 6450cc65d..bcf3a34d4 100644
--- a/pennylane/optimize/rotosolve.py
+++ b/pennylane/optimize/rotosolve.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Rotosolve gradient free optimizer"""
-# pylint: disable=too-many-branches,cell-var-from-loop
+
 
 from inspect import signature
 
@@ -332,8 +332,6 @@ class RotosolveOptimizer:
     dependence on the input arguments and still found the global minimum successfully.
     """
 
-    # pylint: disable=too-few-public-methods
-
     def __init__(self, substep_optimizer="brute", substep_kwargs=None):
         self.substep_kwargs = {} if substep_kwargs is None else substep_kwargs
         if substep_optimizer == "brute":
diff --git a/pennylane/optimize/shot_adaptive.py b/pennylane/optimize/shot_adaptive.py
index 7f855f795..363b7ddd1 100644
--- a/pennylane/optimize/shot_adaptive.py
+++ b/pennylane/optimize/shot_adaptive.py
@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Shot adaptive optimizer"""
-# pylint: disable=too-many-instance-attributes,too-many-arguments,too-many-branches
+# pylint: disable=too-many-instance-attributes,too-many-arguments
+
+
 from copy import copy
 
 import numpy as np
@@ -261,7 +263,7 @@ class ShotAdaptiveOptimizer(GradientDescentOptimizer):
             if s > 1:
 
                 def cost(*args, **kwargs):
-                    # pylint: disable=cell-var-from-loop
+
                     return math.stack(qnode(*args, **kwargs))
 
             else:
@@ -345,9 +347,9 @@ class ShotAdaptiveOptimizer(GradientDescentOptimizer):
 
         return grads
 
-    def compute_grad(
-        self, objective_fn, args, kwargs
-    ):  # pylint: disable=signature-differs,arguments-differ,arguments-renamed
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=arguments-differ
+    def compute_grad(self, objective_fn, args, kwargs):  # pylint: disable=arguments-renamed
         r"""Compute the gradient of the objective function, as well as the variance of the gradient,
         at the given point.
 
diff --git a/pennylane/optimize/spsa.py b/pennylane/optimize/spsa.py
index f7863332b..5e65b935b 100644
--- a/pennylane/optimize/spsa.py
+++ b/pennylane/optimize/spsa.py
@@ -265,7 +265,7 @@ class SPSAOptimizer:
         yplus = objective_fn(*thetaplus, **kwargs)
         yminus = objective_fn(*thetaminus, **kwargs)
         try:
-            # pylint: disable=protected-access
+
             dev_shots = objective_fn.device.shots
 
             shots = dev_shots if dev_shots.has_partitioned_shots else Shots(None)
diff --git a/pennylane/pauli/conversion.py b/pennylane/pauli/conversion.py
index 52a20083b..a6e207a6a 100644
--- a/pennylane/pauli/conversion.py
+++ b/pennylane/pauli/conversion.py
@@ -28,7 +28,6 @@ from .pauli_arithmetic import I, PauliSentence, PauliWord, X, Y, Z, op_map
 from .utils import is_pauli_word
 
 
-# pylint: disable=too-many-branches
 def _generalized_pauli_decompose(
     matrix, hide_identity=False, wire_order=None, pauli=False, padding=False
 ) -> tuple[qml.typing.TensorLike, list]:
@@ -385,8 +384,10 @@ def _(op: PauliZ):
     return PauliSentence({PauliWord({op.wires[0]: Z}): 1.0})
 
 
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=unused-argument
 @_pauli_sentence.register
-def _(op: Identity):  # pylint:disable=unused-argument
+def _(op: Identity):
     return PauliSentence({PauliWord({}): 1.0})
 
 
diff --git a/pennylane/pauli/grouping/group_observables.py b/pennylane/pauli/grouping/group_observables.py
index cc76991ca..0cc7a783a 100644
--- a/pennylane/pauli/grouping/group_observables.py
+++ b/pennylane/pauli/grouping/group_observables.py
@@ -52,7 +52,7 @@ except AttributeError:  # pragma: no cover
 GRAPH_COLOURING_METHODS = frozenset(RX_STRATEGIES.keys()).union({"rlf"})
 
 
-class PauliGroupingStrategy:  # pylint: disable=too-many-instance-attributes
+class PauliGroupingStrategy:
     """
     Class for partitioning a list of Pauli words according to some binary symmetric relation.
 
@@ -444,7 +444,7 @@ def _compute_partition_indices_rlf(observables: list, grouping_type: str):
 
     indices = []
     available_indices = list(range(len(observables)))
-    for partition in obs_groups:  # pylint:disable=too-many-nested-blocks
+    for partition in obs_groups:
         indices_this_group = []
         for pauli_word in partition:
             # find index of this pauli word in remaining original observables,
@@ -565,7 +565,7 @@ def _partition_coeffs(partitioned_paulis, observables, coefficients):
     # we cannot delete elements from the coefficients tensor, so we
     # use a proxy list memorising the indices for this logic
     coeff_indices = list(range(qml.math.shape(coefficients)[0]))
-    for i, partition in enumerate(partitioned_paulis):  # pylint:disable=too-many-nested-blocks
+    for i, partition in enumerate(partitioned_paulis):
         indices = []
         for pauli_word in partition:
             # find index of this pauli word in remaining original observables,
diff --git a/pennylane/pauli/pauli_interface.py b/pennylane/pauli/pauli_interface.py
index 717d4fb1f..0e44f7b1b 100644
--- a/pennylane/pauli/pauli_interface.py
+++ b/pennylane/pauli/pauli_interface.py
@@ -59,7 +59,7 @@ def _pauli_word_prefactor(observable):
 @_pauli_word_prefactor.register(Identity)
 def _pw_prefactor_pauli(
     observable: Union[PauliX, PauliY, PauliZ, Identity],
-):  # pylint:disable=unused-argument
+):
     return 1
 
 
diff --git a/pennylane/pauli/utils.py b/pennylane/pauli/utils.py
index 58e989e64..2bdbf9450 100644
--- a/pennylane/pauli/utils.py
+++ b/pennylane/pauli/utils.py
@@ -106,7 +106,7 @@ def _is_pauli_word(observable):  # pylint:disable=unused-argument
 @_is_pauli_word.register(Identity)
 def _is_pw_pauli(
     observable: Union[PauliX, PauliY, PauliZ, Identity],
-):  # pylint:disable=unused-argument
+):
     return True
 
 
@@ -127,7 +127,6 @@ def _is_pw_sprod(observable: SProd):
 
 
 def are_identical_pauli_words(pauli_1, pauli_2):
-    # pylint: disable=isinstance-second-argument-not-valid-type
     """Performs a check if two Pauli words have the same ``wires`` and ``name`` attributes.
 
     This is a convenience function that checks if two given :class:`~.Prod`
@@ -163,7 +162,6 @@ def are_identical_pauli_words(pauli_1, pauli_2):
 
 
 def pauli_to_binary(pauli_word, n_qubits=None, wire_map=None, check_is_pauli_word=True):
-    # pylint: disable=isinstance-second-argument-not-valid-type
     """Converts a Pauli word to the binary vector (symplectic) representation.
 
     This functions follows convention that the first half of binary vector components specify
@@ -1047,7 +1045,7 @@ def diagonalize_pauli_word(pauli_word):
 @qml.QueuingManager.stop_recording()
 def diagonalize_qwc_pauli_words(
     qwc_grouping,
-):  # pylint: disable=too-many-branches, isinstance-second-argument-not-valid-type
+):
     """Diagonalizes a list of mutually qubit-wise commutative Pauli words.
 
     Args:
diff --git a/pennylane/pulse/hardware_hamiltonian.py b/pennylane/pulse/hardware_hamiltonian.py
index a4593c640..fd6c40a2f 100644
--- a/pennylane/pulse/hardware_hamiltonian.py
+++ b/pennylane/pulse/hardware_hamiltonian.py
@@ -43,7 +43,7 @@ def drive(amplitude, phase, wires):
 
     Common hardware systems are superconducting qubits and neutral atoms. The electromagnetic field of the drive is
     realized by microwave and laser fields, respectively, operating at very different wavelengths.
-    To avoid nummerical problems due to using both very large and very small numbers, it is advisable to match
+    To avoid numerical problems due to using both very large and very small numbers, it is advisable to match
     the order of magnitudes of frequency and time arguments.
     Read the usage details for more information on how to choose :math:`\Omega` and :math:`\phi`.
 
@@ -71,6 +71,8 @@ def drive(amplitude, phase, wires):
 
     .. code-block:: python3
 
+        import jax.numpy as jnp
+
         wires = [0, 1, 2, 3]
         H_int = sum([qml.X(i) @ qml.X((i+1)%len(wires)) for i in wires])
 
@@ -79,10 +81,12 @@ def drive(amplitude, phase, wires):
         H_d = qml.pulse.drive(amplitude, phase, wires)
 
     >>> H_int
-    (1) [X0 X1]
-    + (1) [X1 X2]
-    + (1) [X2 X3]
-    + (1) [X3 X0]
+    (
+    X(0) @ X(1)
+    + X(1) @ X(2)
+    + X(2) @ X(3)
+    + X(3) @ X(0)
+    )
     >>> H_d
     HardwareHamiltonian:: terms=2
 
@@ -96,6 +100,8 @@ def drive(amplitude, phase, wires):
 
     .. code-block:: python3
 
+        import jax
+
         jax.config.update("jax_enable_x64", True)
 
         dev = qml.device("default.qubit", wires=wires)
@@ -107,9 +113,9 @@ def drive(amplitude, phase, wires):
 
     >>> params = [2.4]
     >>> circuit(params)
-    Array(0.32495208, dtype=float64)
+    Array(-0.17375104, dtype=float64)
     >>> jax.grad(circuit)(params)
-    [Array(1.31956098, dtype=float64, weak_type=True)]
+    [Array(13.66916253, dtype=float64, weak_type=True)]
 
     We can also create a Hamiltonian with multiple local drives. The following circuit corresponds to the
     evolution where an additional local drive that changes in time is acting on wires ``[0, 1]`` is added to the Hamiltonian:
@@ -137,8 +143,8 @@ def drive(amplitude, phase, wires):
     Array(0.37385014, dtype=float64)
     >>> jax.grad(circuit_local)(params)
     (Array(-3.35835837, dtype=float64),
-     [Array(-3.35835837, dtype=float64, weak_type=True),
-      Array(-3.35835837, dtype=float64, weak_type=True)],
+     [Array(-1.02229985, dtype=float64, weak_type=True),
+      Array(2.82368978, dtype=float64, weak_type=True)],
      Array(0.1339487, dtype=float64))
 
     .. details::
@@ -165,7 +171,7 @@ def drive(amplitude, phase, wires):
         levels, is unaffected by this transformation.
 
         Further, note that the factor :math:`\frac{1}{2}` is a matter of convention. We keep it for ``drive()`` as well as :func:`~.rydberg_drive`,
-        but ommit it in :func:`~.transmon_drive`, as is common in the respective fields.
+        but omit it in :func:`~.transmon_drive`, as is common in the respective fields.
 
     .. details::
         **Neutral Atom Rydberg systems**
@@ -362,7 +368,7 @@ class HardwareHamiltonian(ParametrizedHamiltonian):
                 new_coeffs, new_ops, reorder_fn=self.reorder_fn, settings=settings, pulses=pulses
             )
 
-        if isinstance(other, qml.ops.SProd):  # pylint: disable=no-member
+        if isinstance(other, qml.ops.SProd):
             new_coeffs = coeffs + [other.scalar]
             new_ops = ops + [other.base]
             return HardwareHamiltonian(
diff --git a/pennylane/pulse/parametrized_evolution.py b/pennylane/pulse/parametrized_evolution.py
index 1e4f74deb..19037a41b 100644
--- a/pennylane/pulse/parametrized_evolution.py
+++ b/pennylane/pulse/parametrized_evolution.py
@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=too-few-public-methods,function-redefined
 
 """
 This file contains the ``ParametrizedEvolution`` operator.
@@ -508,7 +507,6 @@ class ParametrizedEvolution(Operation):
     def has_matrix(self):
         return self._has_matrix
 
-    # pylint: disable=import-outside-toplevel
     def matrix(self, wire_order=None):
         if not has_jax:
             raise ImportError(
diff --git a/pennylane/pulse/parametrized_hamiltonian.py b/pennylane/pulse/parametrized_hamiltonian.py
index a53bc9748..4b9283954 100644
--- a/pennylane/pulse/parametrized_hamiltonian.py
+++ b/pennylane/pulse/parametrized_hamiltonian.py
@@ -24,7 +24,6 @@ from pennylane.typing import TensorLike
 from pennylane.wires import Wires
 
 
-# pylint: disable= too-many-instance-attributes
 class ParametrizedHamiltonian:
     r"""Callable object holding the information representing a parametrized Hamiltonian.
 
@@ -348,7 +347,7 @@ class ParametrizedHamiltonian:
             new_ops = ops + H.ops.copy()
             return ParametrizedHamiltonian(new_coeffs, new_ops)
 
-        if isinstance(H, qml.ops.SProd):  # pylint: disable=no-member
+        if isinstance(H, qml.ops.SProd):
             new_coeffs = coeffs + [H.scalar]
             new_ops = ops + [H.base]
             return ParametrizedHamiltonian(new_coeffs, new_ops)
@@ -373,7 +372,7 @@ class ParametrizedHamiltonian:
             new_ops = H.ops.copy() + ops
             return ParametrizedHamiltonian(new_coeffs, new_ops)
 
-        if isinstance(H, qml.ops.SProd):  # pylint: disable=no-member
+        if isinstance(H, qml.ops.SProd):
             new_coeffs = [H.scalar] + coeffs
             new_ops = [H.base] + ops
             return ParametrizedHamiltonian(new_coeffs, new_ops)
diff --git a/pennylane/pytrees/pytrees.py b/pennylane/pytrees/pytrees.py
index 425558a42..287d6c8fe 100644
--- a/pennylane/pytrees/pytrees.py
+++ b/pennylane/pytrees/pytrees.py
@@ -296,6 +296,7 @@ def _unflatten(new_data, structure):
     return unflatten_registrations[structure.type_](children, structure.metadata)
 
 
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
 # pylint: disable=no-member
 register_pytree(
     autograd.builtins.list,
diff --git a/pennylane/qchem/basis_data.py b/pennylane/qchem/basis_data.py
index 52dc685c0..2b46afa9e 100644
--- a/pennylane/qchem/basis_data.py
+++ b/pennylane/qchem/basis_data.py
@@ -793,7 +793,7 @@ def load_basisset(basis, element):
      'coefficients': [[0.04013973935, 0.261246097, 0.7931846246], [1.0]]}
     """
     try:
-        # pylint: disable=import-outside-toplevel, unused-import, multiple-imports
+        # pylint: disable=import-outside-toplevel
         import basis_set_exchange as bse
     except ImportError as Error:
         raise ImportError(
diff --git a/pennylane/qchem/convert.py b/pennylane/qchem/convert.py
index a86b7181b..ad2ce0e01 100644
--- a/pennylane/qchem/convert.py
+++ b/pennylane/qchem/convert.py
@@ -14,12 +14,16 @@
 """
 This module contains the functions for converting an external operator to a Pennylane operator.
 """
+
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=too-many-function-args
+
 import warnings
 from itertools import product
 
 import numpy as np
 
-# pylint: disable= import-outside-toplevel,no-member,too-many-function-args
+# pylint: disable=import-outside-toplevel
 import pennylane as qml
 from pennylane.wires import Wires
 
@@ -194,7 +198,6 @@ def _ps_to_coeff_term(ps, wire_order):
     return coeffs, ops_str
 
 
-# pylint:disable=too-many-branches
 def _pennylane_to_openfermion(coeffs, ops, wires=None, tol=1.0e-16):
     r"""Convert a 2-tuple of complex coefficients and PennyLane operations to
     OpenFermion ``QubitOperator``.
diff --git a/pennylane/qchem/convert_openfermion.py b/pennylane/qchem/convert_openfermion.py
index f0c616554..1dc505dd2 100644
--- a/pennylane/qchem/convert_openfermion.py
+++ b/pennylane/qchem/convert_openfermion.py
@@ -18,7 +18,6 @@ This module contains the functions for converting between OpenFermion and PennyL
 from functools import singledispatch
 from typing import Union
 
-# pylint: disable= import-outside-toplevel,no-member,unused-import
 import pennylane as qml
 from pennylane import numpy as np
 from pennylane.fermi.fermionic import FermiSentence, FermiWord
@@ -29,7 +28,7 @@ from pennylane.qchem.convert import _openfermion_to_pennylane, _pennylane_to_ope
 def _import_of():
     """Import openfermion."""
     try:
-        # pylint: disable=import-outside-toplevel, unused-import, multiple-imports
+        # pylint: disable=import-outside-toplevel
         import openfermion
     except ImportError as Error:
         raise ImportError(
@@ -158,9 +157,11 @@ def _(pl_op: Sum, wires=None, tol=1.0e-16):
     return _pennylane_to_openfermion(np.array(coeffs), ops, wires=wires, tol=tol)
 
 
-# pylint: disable=unused-argument, protected-access
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=unused-argument
 @_to_openfermion_dispatch.register
 def _(ops: FermiWord, wires=None, tol=1.0e-16):
+    # pylint: disable=protected-access
     openfermion = _import_of()
 
     if wires:
diff --git a/pennylane/qchem/dipole.py b/pennylane/qchem/dipole.py
index f036fe0db..18a351419 100644
--- a/pennylane/qchem/dipole.py
+++ b/pennylane/qchem/dipole.py
@@ -332,7 +332,7 @@ def molecular_dipole(
     wires=None,
     args=None,
     cutoff=1.0e-16,
-):  # pylint:disable=too-many-arguments, too-many-statements, protected-access
+):  # pylint: disable=too-many-arguments,protected-access
     r"""Generate the dipole moment operator for a molecule in the Pauli basis.
 
     The dipole operator in the second-quantized form is
diff --git a/pennylane/qchem/factorization.py b/pennylane/qchem/factorization.py
index bc5833c81..834be7da1 100644
--- a/pennylane/qchem/factorization.py
+++ b/pennylane/qchem/factorization.py
@@ -23,7 +23,7 @@ import pennylane as qml
 
 has_jax_optax = True
 try:  # pragma: no cover
-    # pylint: disable=unused-import
+
     import optax
     from jax import jit
     from jax import numpy as jnp
@@ -742,7 +742,8 @@ def _chemist_transform(one_body_tensor=None, two_body_tensor=None, spatial_basis
 
     if two_body_tensor is not None:
         chemist_two_body_coeffs = np.swapaxes(two_body_tensor, 1, 3)
-        # pylint:disable=invalid-unary-operand-type
+        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+        # pylint: disable=invalid-unary-operand-type
         one_body_coeffs = -np.einsum("prrs", chemist_two_body_coeffs)
 
         if chemist_one_body_coeffs is None:
diff --git a/pennylane/qchem/hamiltonian.py b/pennylane/qchem/hamiltonian.py
index 20c99e432..d910ef0ab 100644
--- a/pennylane/qchem/hamiltonian.py
+++ b/pennylane/qchem/hamiltonian.py
@@ -23,7 +23,7 @@ from .hartree_fock import nuclear_energy, scf
 from .molecule import Molecule
 from .observable_hf import fermionic_observable, qubit_observable
 
-# pylint: disable= too-many-branches, too-many-arguments, too-many-locals, too-many-nested-blocks
+# pylint: disable=too-many-branches,too-many-arguments,too-many-locals
 # pylint: disable=consider-using-generator, protected-access, too-many-positional-arguments
 # pylint: disable=possibly-used-before-assignment
 
@@ -500,7 +500,7 @@ def _molecular_hamiltonian(
     args=None,
     load_data=False,
     convert_tol=1e12,
-):  # pylint:disable=too-many-arguments, too-many-statements
+):  # pylint: disable=too-many-arguments
     r"""Generate the qubit Hamiltonian of a molecule."""
 
     method = method.strip().lower()
diff --git a/pennylane/qchem/matrices.py b/pennylane/qchem/matrices.py
index a9bebbec6..f16221f0f 100644
--- a/pennylane/qchem/matrices.py
+++ b/pennylane/qchem/matrices.py
@@ -14,7 +14,7 @@
 """
 This module contains the functions needed for computing matrices.
 """
-# pylint: disable= too-many-branches
+
 import itertools as it
 
 import numpy as np
diff --git a/pennylane/qchem/molecule.py b/pennylane/qchem/molecule.py
index 6aa77a3bd..01a6bbf4e 100644
--- a/pennylane/qchem/molecule.py
+++ b/pennylane/qchem/molecule.py
@@ -18,7 +18,7 @@ the necessary information to perform a Hartree-Fock calculation for a given mole
 """
 import collections
 
-# pylint: disable=too-few-public-methods, too-many-arguments, too-many-instance-attributes
+# pylint: disable=too-many-arguments,too-many-instance-attributes
 import itertools
 import warnings
 
diff --git a/pennylane/qchem/observable_hf.py b/pennylane/qchem/observable_hf.py
index 3848e5ccd..5c2092982 100644
--- a/pennylane/qchem/observable_hf.py
+++ b/pennylane/qchem/observable_hf.py
@@ -14,7 +14,7 @@
 """
 This module contains the functions needed for creating fermionic and qubit observables.
 """
-# pylint: disable= too-many-branches, too-many-return-statements
+
 import numpy as np
 
 import pennylane as qml
diff --git a/pennylane/qchem/openfermion_pyscf.py b/pennylane/qchem/openfermion_pyscf.py
index 51aa3deff..a95d02b13 100644
--- a/pennylane/qchem/openfermion_pyscf.py
+++ b/pennylane/qchem/openfermion_pyscf.py
@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """This module contains functions to construct many-body observables with ``OpenFermion-PySCF``."""
-# pylint: disable=too-many-arguments, too-few-public-methods, too-many-branches, unused-variable
-# pylint: disable=consider-using-generator, protected-access
+# pylint: disable=too-many-arguments,unused-variable
+# pylint: disable=consider-using-generator
 import os
 
 import numpy as np
@@ -29,7 +29,7 @@ bohr_angs = 0.529177210903
 def _import_of():
     """Import openfermion and openfermionpyscf."""
     try:
-        # pylint: disable=import-outside-toplevel, unused-import, multiple-imports
+        # pylint: disable=import-outside-toplevel
         import openfermion
         import openfermionpyscf
     except ImportError as Error:
@@ -44,7 +44,7 @@ def _import_of():
 def _import_pyscf():
     """Import pyscf."""
     try:
-        # pylint: disable=import-outside-toplevel, unused-import, multiple-imports
+        # pylint: disable=import-outside-toplevel
         import pyscf
     except ImportError as Error:
         raise ImportError(
diff --git a/pennylane/qchem/structure.py b/pennylane/qchem/structure.py
index b48e537e8..48e736f18 100644
--- a/pennylane/qchem/structure.py
+++ b/pennylane/qchem/structure.py
@@ -553,7 +553,7 @@ def mol_data(identifier, identifier_type="name"):
     """
 
     try:
-        # pylint: disable=import-outside-toplevel, unused-import, multiple-imports
+        # pylint: disable=import-outside-toplevel
         import pubchempy as pcp
     except ImportError as Error:
         raise ImportError(
diff --git a/pennylane/qchem/tapering.py b/pennylane/qchem/tapering.py
index 3e4bb622c..4844a4612 100644
--- a/pennylane/qchem/tapering.py
+++ b/pennylane/qchem/tapering.py
@@ -14,7 +14,7 @@
 """
 This module contains the functions needed for tapering qubits using symmetries.
 """
-# pylint: disable=unnecessary-lambda
+
 
 import functools
 import itertools
@@ -175,7 +175,7 @@ def symmetry_generators(h):
     return generators
 
 
-def paulix_ops(generators, num_qubits):  # pylint: disable=protected-access
+def paulix_ops(generators, num_qubits):
     r"""Generate the single qubit Pauli-X operators :math:`\sigma^{x}_{i}` for each symmetry :math:`\tau_j`,
     such that it anti-commutes with :math:`\tau_j` and commutes with all others symmetries :math:`\tau_{k\neq j}`.
     These are required to obtain the Clifford operators :math:`U` for the Hamiltonian :math:`H`.
@@ -607,8 +607,8 @@ def _build_generator(operation, wire_order, op_gen=None):
     return op_gen
 
 
-# pylint: disable=too-many-branches, too-many-arguments, too-many-positional-arguments
-# pylint: disable=inconsistent-return-statements, no-member
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+# pylint: disable=inconsistent-return-statements
 def taper_operation(
     operation, generators, paulixops, paulix_sector, wire_order, op_wires=None, op_gen=None
 ):
diff --git a/pennylane/qchem/vibrational/localize_modes.py b/pennylane/qchem/vibrational/localize_modes.py
index a8aded5b1..92aa94eea 100644
--- a/pennylane/qchem/vibrational/localize_modes.py
+++ b/pennylane/qchem/vibrational/localize_modes.py
@@ -20,7 +20,7 @@ import scipy
 
 import pennylane as qml
 
-# pylint: disable=dangerous-default-value, too-many-statements
+# pylint: disable=dangerous-default-value
 
 
 def _mat_transform(u, qmat):
diff --git a/pennylane/qchem/vibrational/vibrational_class.py b/pennylane/qchem/vibrational/vibrational_class.py
index 6274f556b..f12358c7e 100644
--- a/pennylane/qchem/vibrational/vibrational_class.py
+++ b/pennylane/qchem/vibrational/vibrational_class.py
@@ -227,7 +227,8 @@ def _get_rhf_dipole(scf_result):
     for num_atom in range(len(charges)):
         centered_coords[num_atom, :] -= nuc_mass_center
     dipole_n = np.einsum("z,zx->x", charges, centered_coords)
-
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=invalid-unary-operand-type
     dipole = -dipole_e + dipole_n
     return dipole
 
diff --git a/pennylane/qcut/cutstrategy.py b/pennylane/qcut/cutstrategy.py
index f5986c8e0..b3a521d24 100644
--- a/pennylane/qcut/cutstrategy.py
+++ b/pennylane/qcut/cutstrategy.py
@@ -81,7 +81,7 @@ class CutStrategy:
 
     """
 
-    # pylint: disable=too-many-arguments, too-many-instance-attributes
+    # pylint: disable=too-many-instance-attributes
 
     #: Initialization argument only, used to derive ``max_free_wires`` and ``min_free_wires``.
     devices: InitVar[Union[SupportedDeviceAPIs, Sequence[SupportedDeviceAPIs]]] = None
diff --git a/pennylane/qcut/tapes.py b/pennylane/qcut/tapes.py
index bf856c70b..9a1892210 100644
--- a/pennylane/qcut/tapes.py
+++ b/pennylane/qcut/tapes.py
@@ -103,7 +103,6 @@ def tape_to_graph(tape: QuantumScript) -> MultiDiGraph:
     return graph
 
 
-# pylint: disable=protected-access
 def graph_to_tape(graph: MultiDiGraph) -> QuantumScript:
     """
     Converts a directed multigraph to the corresponding :class:`~.QuantumTape`.
diff --git a/pennylane/qcut/utils.py b/pennylane/qcut/utils.py
index 168531fcf..8c2d85cd0 100644
--- a/pennylane/qcut/utils.py
+++ b/pennylane/qcut/utils.py
@@ -710,7 +710,7 @@ def _is_valid_cut(
 
     correct_num_fragments = k <= num_fragments_requested
     best_candidate_yet = (key not in cut_candidates) or (len(cut_candidates[key]) > num_cuts)
-    # pylint: disable=no-member
+
     all_fragments_fit = all(
         len(qml.qcut.graph_to_tape(f).wires) <= max_free_wires for j, f in enumerate(fragments)
     )
diff --git a/pennylane/qnn/torch.py b/pennylane/qnn/torch.py
index 0fb0efc39..da82d3b16 100644
--- a/pennylane/qnn/torch.py
+++ b/pennylane/qnn/torch.py
@@ -383,7 +383,7 @@ class TorchLayer(Module):
         } != set(sig.keys()):
             raise ValueError("Must specify a shape for every non-input parameter in the QNode")
 
-    def forward(self, inputs):  # pylint: disable=arguments-differ
+    def forward(self, inputs):
         """Evaluates a forward pass through the QNode based upon input data and the initialized
         weights.
 
diff --git a/pennylane/spin/lattice.py b/pennylane/spin/lattice.py
index fffbe8a57..9b9cf8335 100644
--- a/pennylane/spin/lattice.py
+++ b/pennylane/spin/lattice.py
@@ -23,7 +23,7 @@ import scipy as sp
 from pennylane import math
 
 # pylint: disable=too-many-arguments, too-many-instance-attributes
-# pylint: disable=use-a-generator, too-few-public-methods
+# pylint: disable=too-few-public-methods
 # pylint: disable=too-many-branches
 
 
diff --git a/pennylane/spin/spin_hamiltonian.py b/pennylane/spin/spin_hamiltonian.py
index e16063c72..73159f3e5 100644
--- a/pennylane/spin/spin_hamiltonian.py
+++ b/pennylane/spin/spin_hamiltonian.py
@@ -22,7 +22,7 @@ from pennylane.ops.identity import I
 
 from .lattice import Lattice, generate_lattice
 
-# pylint: disable=too-many-arguments, too-many-branches
+# pylint: disable=too-many-arguments
 
 
 def transverse_ising(
diff --git a/pennylane/tape/operation_recorder.py b/pennylane/tape/operation_recorder.py
index 49c2c4190..519b28f56 100644
--- a/pennylane/tape/operation_recorder.py
+++ b/pennylane/tape/operation_recorder.py
@@ -14,7 +14,7 @@
 """
 This module contains the :class:`OperationRecorder`.
 """
-# pylint: disable=too-many-arguments
+
 from pennylane.queuing import AnnotatedQueue, QueuingManager, process_queue
 
 from .tape import QuantumScript
@@ -48,7 +48,7 @@ class OperationRecorder(QuantumScript, AnnotatedQueue):
         ops=None,
         measurements=None,
         shots=None,
-    ):  # pylint: disable=unused-argument, too-many-arguments
+    ):
         AnnotatedQueue.__init__(self)
         QuantumScript.__init__(self, ops, measurements, shots)
         self.ops = None
diff --git a/pennylane/tape/plxpr_conversion.py b/pennylane/tape/plxpr_conversion.py
index bf0731a5b..590eeaa4c 100644
--- a/pennylane/tape/plxpr_conversion.py
+++ b/pennylane/tape/plxpr_conversion.py
@@ -177,7 +177,6 @@ def _(self, wires, reset, postselect):
     return m0
 
 
-# pylint: disable=unused-argument
 @CollectOpsandMeas.register_primitive(grad_prim)
 def _(self, *invals, jaxpr, n_consts, **params):
     raise NotImplementedError("CollectOpsandMeas cannot handle the grad primitive")
@@ -192,7 +191,7 @@ def _(self, *invals, jaxpr, n_consts, **params):
 @CollectOpsandMeas.register_primitive(qnode_prim)
 def _(
     self, *invals, shots, qnode, device, execution_config, qfunc_jaxpr, n_consts
-):  # pylint: disable=too-many-arguments,unused-argument
+):  # pylint: disable=too-many-arguments
     consts = invals[:n_consts]
     args = invals[n_consts:]
 
diff --git a/pennylane/tape/qscript.py b/pennylane/tape/qscript.py
index 83335bf10..71419f1bc 100644
--- a/pennylane/tape/qscript.py
+++ b/pennylane/tape/qscript.py
@@ -740,7 +740,6 @@ class QuantumScript:
         >>> newer_qscript.get_parameters()
         [-0.1, 0.2, 0.5]
         """
-        # pylint: disable=no-member
 
         if len(params) != len(indices):
             raise ValueError("Number of provided parameters does not match number of indices")
@@ -1245,7 +1244,7 @@ class QuantumScript:
             operations += self.diagonalizing_gates
 
         # decompose the queue
-        # pylint: disable=no-member
+
         just_ops = QuantumScript(operations)
         operations = just_ops.expand(
             depth=10, stop_at=lambda obj: obj.name in OPENQASM_GATES
diff --git a/pennylane/tape/tape.py b/pennylane/tape/tape.py
index 683775480..6be08911a 100644
--- a/pennylane/tape/tape.py
+++ b/pennylane/tape/tape.py
@@ -14,7 +14,7 @@
 """
 This module contains the base quantum tape.
 """
-# pylint: disable=too-many-instance-attributes,protected-access,too-many-branches,too-many-public-methods, too-many-arguments
+# pylint: disable=protected-access
 import copy
 from collections.abc import Sequence
 from threading import RLock
@@ -341,7 +341,6 @@ def expand_tape_state_prep(tape, skip_first=True):
     return new_tape
 
 
-# pylint: disable=too-many-public-methods
 class QuantumTape(QuantumScript, AnnotatedQueue):
     r"""A quantum tape recorder, that records and stores variational quantum programs.
 
@@ -477,9 +476,7 @@ class QuantumTape(QuantumScript, AnnotatedQueue):
     _lock = RLock()
     """threading.RLock: Used to synchronize appending to/popping from global QueueingContext."""
 
-    def __init__(
-        self, ops=None, measurements=None, shots=None, trainable_params=None
-    ):  # pylint: disable=too-many-arguments
+    def __init__(self, ops=None, measurements=None, shots=None, trainable_params=None):
         AnnotatedQueue.__init__(self)
         QuantumScript.__init__(self, ops, measurements, shots, trainable_params=trainable_params)
 
diff --git a/pennylane/templates/layers/basic_entangler.py b/pennylane/templates/layers/basic_entangler.py
index 133e53ff3..0bcdf144a 100644
--- a/pennylane/templates/layers/basic_entangler.py
+++ b/pennylane/templates/layers/basic_entangler.py
@@ -15,8 +15,6 @@ r"""
 Contains the BasicEntanglerLayers template.
 """
 from pennylane import math
-
-# pylint: disable=consider-using-enumerate,too-many-arguments
 from pennylane.operation import Operation
 from pennylane.ops import CNOT, RX
 
diff --git a/pennylane/templates/state_preparations/arbitrary_state_preparation.py b/pennylane/templates/state_preparations/arbitrary_state_preparation.py
index 3b8dbddb2..51e8f1959 100644
--- a/pennylane/templates/state_preparations/arbitrary_state_preparation.py
+++ b/pennylane/templates/state_preparations/arbitrary_state_preparation.py
@@ -14,7 +14,7 @@
 r"""
 Contains the ArbitraryStatePreparation template.
 """
-# pylint: disable=trailing-comma-tuple
+
 import functools
 
 import pennylane as qml
diff --git a/pennylane/templates/state_preparations/cosine_window.py b/pennylane/templates/state_preparations/cosine_window.py
index 57869434b..c34725a3c 100644
--- a/pennylane/templates/state_preparations/cosine_window.py
+++ b/pennylane/templates/state_preparations/cosine_window.py
@@ -60,7 +60,7 @@ class CosineWindow(StatePrepBase):
     """
 
     @staticmethod
-    def compute_decomposition(wires):  # pylint: disable=arguments-differ,unused-argument
+    def compute_decomposition(wires):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators (static method).
         It is efficiently decomposed from one QFT over all qubits and one-qubit rotation gates.
 
@@ -85,7 +85,7 @@ class CosineWindow(StatePrepBase):
     def label(self, decimals=None, base_label=None, cache=None):
         return "CosineWindow"
 
-    def state_vector(self, wire_order=None):  # pylint: disable=arguments-differ,unused-argument
+    def state_vector(self, wire_order=None):
         r"""Calculation of the state vector generated by the cosine window.
 
         Args:
diff --git a/pennylane/templates/state_preparations/qrom_state_prep.py b/pennylane/templates/state_preparations/qrom_state_prep.py
index 4e3fe6aa8..6921b714a 100644
--- a/pennylane/templates/state_preparations/qrom_state_prep.py
+++ b/pennylane/templates/state_preparations/qrom_state_prep.py
@@ -167,7 +167,7 @@ class QROMStatePreparation(Operation):
     @staticmethod
     def compute_decomposition(
         state_vector, wires, input_wires, precision_wires, work_wires
-    ):  # pylint: disable=arguments-differ,too-many-positional-arguments
+    ):  # pylint: disable=arguments-differ
         r"""
         Computes the decomposition operations for the given state vector.
 
diff --git a/pennylane/templates/state_preparations/state_prep_mps.py b/pennylane/templates/state_preparations/state_prep_mps.py
index 96d809a2f..48ca6e5d5 100644
--- a/pennylane/templates/state_preparations/state_prep_mps.py
+++ b/pennylane/templates/state_preparations/state_prep_mps.py
@@ -402,7 +402,7 @@ class MPSPrep(Operation):
             return type.__call__(cls, mps=mps, wires=wires, id=id)  # pragma: no cover
         return cls._primitive.bind(*mps, wires=wires, id=id)
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
         filtered_hyperparameters = {
             key: value for key, value in self.hyperparameters.items() if key != "input_wires"
         }
diff --git a/pennylane/templates/state_preparations/superposition.py b/pennylane/templates/state_preparations/superposition.py
index 6a59f82b0..ce06a2afa 100644
--- a/pennylane/templates/state_preparations/superposition.py
+++ b/pennylane/templates/state_preparations/superposition.py
@@ -258,7 +258,7 @@ class Superposition(Operation):
         hyperparams_dict = dict(metadata[1])
         return cls(*data, wires=metadata[0], **hyperparams_dict)
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
         return self.compute_decomposition(
             *self.parameters,
             bases=self.hyperparameters["bases"],
diff --git a/pennylane/templates/subroutines/adder.py b/pennylane/templates/subroutines/adder.py
index 2ad462abf..93fd4e745 100644
--- a/pennylane/templates/subroutines/adder.py
+++ b/pennylane/templates/subroutines/adder.py
@@ -159,7 +159,7 @@ class Adder(Operation):
             new_dict["work_wires"],
         )
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
         return self.compute_decomposition(**self.hyperparameters)
 
     @classmethod
diff --git a/pennylane/templates/subroutines/amplitude_amplification.py b/pennylane/templates/subroutines/amplitude_amplification.py
index e70fa588c..4489715e8 100644
--- a/pennylane/templates/subroutines/amplitude_amplification.py
+++ b/pennylane/templates/subroutines/amplitude_amplification.py
@@ -145,7 +145,6 @@ class AmplitudeAmplification(Operation):
 
         super().__init__(*U.data, *O.data, wires=wires)
 
-    # pylint:disable=arguments-differ
     @staticmethod
     def compute_decomposition(*_, **kwargs):
         U = kwargs["U"]
diff --git a/pennylane/templates/subroutines/approx_time_evolution.py b/pennylane/templates/subroutines/approx_time_evolution.py
index ac920fe49..00f7eee5a 100644
--- a/pennylane/templates/subroutines/approx_time_evolution.py
+++ b/pennylane/templates/subroutines/approx_time_evolution.py
@@ -161,7 +161,7 @@ class ApproxTimeEvolution(Operation):
     @staticmethod
     def compute_decomposition(
         *coeffs_and_time, wires, hamiltonian, n
-    ):  # pylint: disable=arguments-differ,unused-argument
+    ):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators.
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/subroutines/commuting_evolution.py b/pennylane/templates/subroutines/commuting_evolution.py
index 0a5fcf490..62fb7489b 100644
--- a/pennylane/templates/subroutines/commuting_evolution.py
+++ b/pennylane/templates/subroutines/commuting_evolution.py
@@ -160,10 +160,12 @@ class CommutingEvolution(Operation):
         context.append(self)
         return self
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=unused-argument
     @staticmethod
     def compute_decomposition(
         time, *_, wires, hamiltonian, **__
-    ):  # pylint: disable=arguments-differ,unused-argument
+    ):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators.
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/subroutines/controlled_sequence.py b/pennylane/templates/subroutines/controlled_sequence.py
index 2fb9afc0c..9ffb91814 100644
--- a/pennylane/templates/subroutines/controlled_sequence.py
+++ b/pennylane/templates/subroutines/controlled_sequence.py
@@ -123,7 +123,7 @@ class ControlledSequence(SymbolicOp, Operation):
         return f"ControlledSequence({self.base}, control={list(self.control)})"
 
     def map_wires(self, wire_map: dict):
-        # pylint:disable=protected-access
+
         new_op = copy(self)
         new_op.hyperparameters["base"] = self.base.map_wires(wire_map=wire_map)
         new_op.hyperparameters["control_wires"] = Wires(
@@ -131,7 +131,8 @@ class ControlledSequence(SymbolicOp, Operation):
         )
         return new_op
 
-    # pylint:disable=arguments-differ
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=arguments-differ
     @staticmethod
     def compute_decomposition(*_, base=None, control_wires=None, lazy=False, **__):
         r"""Representation of the operator as a product of other operators.
diff --git a/pennylane/templates/subroutines/fermionic_double_excitation.py b/pennylane/templates/subroutines/fermionic_double_excitation.py
index 5e1a6ba57..88ebc91c9 100644
--- a/pennylane/templates/subroutines/fermionic_double_excitation.py
+++ b/pennylane/templates/subroutines/fermionic_double_excitation.py
@@ -551,10 +551,10 @@ class FermionicDoubleExcitation(Operation):
     def num_params(self):
         return 1
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=unused-argument
     @staticmethod
-    def compute_decomposition(
-        weight, wires, wires1, wires2
-    ):  # pylint: disable=arguments-differ,unused-argument
+    def compute_decomposition(weight, wires, wires1, wires2):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators.
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/subroutines/gqsp.py b/pennylane/templates/subroutines/gqsp.py
index d676391ad..35c0be143 100644
--- a/pennylane/templates/subroutines/gqsp.py
+++ b/pennylane/templates/subroutines/gqsp.py
@@ -14,7 +14,7 @@
 """
 Contains the GQSP template.
 """
-# pylint: disable=too-many-arguments
+
 
 import copy
 
@@ -118,7 +118,7 @@ class GQSP(Operation):
         return new_op
 
     @staticmethod
-    def compute_decomposition(*parameters, **hyperparameters):  # pylint: disable=arguments-differ
+    def compute_decomposition(*parameters, **hyperparameters):
         r"""
         Representation of the operator as a product of other operators (static method).
 
diff --git a/pennylane/templates/subroutines/hilbert_schmidt.py b/pennylane/templates/subroutines/hilbert_schmidt.py
index 30abb12f0..5ab4cf361 100644
--- a/pennylane/templates/subroutines/hilbert_schmidt.py
+++ b/pennylane/templates/subroutines/hilbert_schmidt.py
@@ -276,7 +276,7 @@ class LocalHilbertSchmidt(HilbertSchmidt):
     @staticmethod
     def compute_decomposition(
         params, wires, u_tape, v_tape, v_function=None, v_wires=None
-    ):  # pylint: disable=arguments-differ,unused-argument,too-many-positional-arguments
+    ):  # pylint: disable=too-many-positional-arguments
         r"""Representation of the operator as a product of other operators (static method)."""
 
         n_wires = len(u_tape.wires + v_tape.wires)
diff --git a/pennylane/templates/subroutines/mod_exp.py b/pennylane/templates/subroutines/mod_exp.py
index 467ca7396..835e1b1cb 100644
--- a/pennylane/templates/subroutines/mod_exp.py
+++ b/pennylane/templates/subroutines/mod_exp.py
@@ -190,7 +190,7 @@ class ModExp(Operation):
             + self.hyperparameters["work_wires"]
         )
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
 
         return self.compute_decomposition(**self.hyperparameters)
 
diff --git a/pennylane/templates/subroutines/multiplier.py b/pennylane/templates/subroutines/multiplier.py
index 1ebe6dde7..5e7fa0845 100644
--- a/pennylane/templates/subroutines/multiplier.py
+++ b/pennylane/templates/subroutines/multiplier.py
@@ -183,7 +183,7 @@ class Multiplier(Operation):
         """All wires involved in the operation."""
         return self.hyperparameters["x_wires"] + self.hyperparameters["work_wires"]
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
         return self.compute_decomposition(**self.hyperparameters)
 
     @classmethod
diff --git a/pennylane/templates/subroutines/out_adder.py b/pennylane/templates/subroutines/out_adder.py
index d8ead9c51..908ec3b20 100644
--- a/pennylane/templates/subroutines/out_adder.py
+++ b/pennylane/templates/subroutines/out_adder.py
@@ -217,7 +217,7 @@ class OutAdder(Operation):
             new_dict["work_wires"],
         )
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
 
         return self.compute_decomposition(**self.hyperparameters)
 
diff --git a/pennylane/templates/subroutines/out_multiplier.py b/pennylane/templates/subroutines/out_multiplier.py
index c58428825..60f48e13f 100644
--- a/pennylane/templates/subroutines/out_multiplier.py
+++ b/pennylane/templates/subroutines/out_multiplier.py
@@ -224,7 +224,7 @@ class OutMultiplier(Operation):
             new_dict["work_wires"],
         )
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
         return self.compute_decomposition(**self.hyperparameters)
 
     @classmethod
diff --git a/pennylane/templates/subroutines/out_poly.py b/pennylane/templates/subroutines/out_poly.py
index f54947ce8..52ffbba98 100644
--- a/pennylane/templates/subroutines/out_poly.py
+++ b/pennylane/templates/subroutines/out_poly.py
@@ -362,7 +362,7 @@ class OutPoly(Operation):
     def _primitive_bind_call(cls, *args, **kwargs):
         return cls._primitive.bind(*args, **kwargs)
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
         return self.compute_decomposition(**self.hyperparameters)
 
     @staticmethod
diff --git a/pennylane/templates/subroutines/phase_adder.py b/pennylane/templates/subroutines/phase_adder.py
index 4c4ffa433..b30ad352c 100644
--- a/pennylane/templates/subroutines/phase_adder.py
+++ b/pennylane/templates/subroutines/phase_adder.py
@@ -186,7 +186,7 @@ class PhaseAdder(Operation):
             new_dict["work_wire"],
         )
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
         return self.compute_decomposition(**self.hyperparameters)
 
     @classmethod
diff --git a/pennylane/templates/subroutines/prepselprep.py b/pennylane/templates/subroutines/prepselprep.py
index bb100bfea..0f92e6a55 100644
--- a/pennylane/templates/subroutines/prepselprep.py
+++ b/pennylane/templates/subroutines/prepselprep.py
@@ -14,7 +14,7 @@
 """
 Contains the PrepSelPrep template.
 """
-# pylint: disable=arguments-differ,import-outside-toplevel,too-many-arguments
+# pylint: disable=arguments-differ
 import copy
 
 import pennylane as qml
diff --git a/pennylane/templates/subroutines/qdrift.py b/pennylane/templates/subroutines/qdrift.py
index b74a1ac00..f2b5e25a6 100644
--- a/pennylane/templates/subroutines/qdrift.py
+++ b/pennylane/templates/subroutines/qdrift.py
@@ -229,7 +229,7 @@ class QDrift(Operation):
         return self
 
     @staticmethod
-    def compute_decomposition(*args, **kwargs):  # pylint: disable=unused-argument
+    def compute_decomposition(*args, **kwargs):
         r"""Representation of the operator as a product of other operators (static method).
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/subroutines/qft.py b/pennylane/templates/subroutines/qft.py
index 2020ad2e0..00ca537ae 100644
--- a/pennylane/templates/subroutines/qft.py
+++ b/pennylane/templates/subroutines/qft.py
@@ -14,7 +14,7 @@
 """
 This submodule contains the template for QFT.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access
+
 
 import functools
 
@@ -156,7 +156,7 @@ class QFT(Operation):
         return np.fft.ifft(np.eye(2**n_wires), norm="ortho")
 
     @staticmethod
-    def compute_decomposition(wires: WiresLike):  # pylint: disable=arguments-differ,unused-argument
+    def compute_decomposition(wires: WiresLike):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators (static method).
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/subroutines/qmc.py b/pennylane/templates/subroutines/qmc.py
index 5ad97e1fc..095772120 100644
--- a/pennylane/templates/subroutines/qmc.py
+++ b/pennylane/templates/subroutines/qmc.py
@@ -350,7 +350,9 @@ class QuantumMonteCarlo(Operation):
     @classmethod
     def _unflatten(cls, data, metadata):
         new_op = cls.__new__(cls)
-        new_op._hyperparameters = dict(metadata[1])  # pylint: disable=protected-access
+        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+        # pylint: disable=protected-access
+        new_op._hyperparameters = dict(metadata[1])
 
         # call operation.__init__ to initialize private properties like _name, _id, _pauli_rep, etc.
         Operation.__init__(new_op, *data, wires=metadata[0])
@@ -400,10 +402,12 @@ class QuantumMonteCarlo(Operation):
     def num_params(self):
         return 3
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=unused-argument
     @staticmethod
     def compute_decomposition(
         A, R, Q, wires, estimation_wires, target_wires
-    ):  # pylint: disable=arguments-differ,unused-argument
+    ):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators.
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/subroutines/qpe.py b/pennylane/templates/subroutines/qpe.py
index 20114b76a..dc32aeafe 100644
--- a/pennylane/templates/subroutines/qpe.py
+++ b/pennylane/templates/subroutines/qpe.py
@@ -14,7 +14,7 @@
 """
 Contains the QuantumPhaseEstimation template.
 """
-# pylint: disable=too-many-arguments,arguments-differ
+# pylint: disable=arguments-differ
 import copy
 
 import pennylane as qml
@@ -143,7 +143,6 @@ class QuantumPhaseEstimation(ErrorOperation):
 
     grad_method = None
 
-    # pylint: disable=no-member
     def _flatten(self):
         data = (self.hyperparameters["unitary"],)
         metadata = (self.hyperparameters["estimation_wires"],)
diff --git a/pennylane/templates/subroutines/qrom.py b/pennylane/templates/subroutines/qrom.py
index 59efb284c..942c2899b 100644
--- a/pennylane/templates/subroutines/qrom.py
+++ b/pennylane/templates/subroutines/qrom.py
@@ -184,7 +184,7 @@ class QROM(Operation):
 
         return copied_op
 
-    def decomposition(self):  # pylint: disable=arguments-differ
+    def decomposition(self):
 
         return self.compute_decomposition(
             self.bitstrings,
diff --git a/pennylane/templates/subroutines/qsvt.py b/pennylane/templates/subroutines/qsvt.py
index 3bf89938c..410b7c131 100644
--- a/pennylane/templates/subroutines/qsvt.py
+++ b/pennylane/templates/subroutines/qsvt.py
@@ -14,7 +14,7 @@
 """
 Contains the QSVT template and qsvt wrapper function.
 """
-# pylint: disable=too-many-arguments
+
 import copy
 from typing import Literal, Sequence, Union
 
diff --git a/pennylane/templates/subroutines/qubitization.py b/pennylane/templates/subroutines/qubitization.py
index e4b097a92..c9e7eeec8 100644
--- a/pennylane/templates/subroutines/qubitization.py
+++ b/pennylane/templates/subroutines/qubitization.py
@@ -124,7 +124,7 @@ class Qubitization(Operation):
         return new_op
 
     @staticmethod
-    def compute_decomposition(*_, **kwargs):  # pylint: disable=arguments-differ
+    def compute_decomposition(*_, **kwargs):
         r"""Representation of the operator as a product of other operators (static method).
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/subroutines/select.py b/pennylane/templates/subroutines/select.py
index 66a54f090..a8758c371 100644
--- a/pennylane/templates/subroutines/select.py
+++ b/pennylane/templates/subroutines/select.py
@@ -14,7 +14,7 @@
 """
 Contains the Select template.
 """
-# pylint: disable=too-many-arguments
+
 
 import copy
 import itertools
@@ -167,7 +167,7 @@ class Select(Operation):
     def compute_decomposition(
         ops,
         control,
-    ):  # pylint: disable=arguments-differ, unused-argument
+    ):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators (static method).
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/swapnetworks/ccl2.py b/pennylane/templates/swapnetworks/ccl2.py
index 8866fcfd2..dc9ebcfbc 100644
--- a/pennylane/templates/swapnetworks/ccl2.py
+++ b/pennylane/templates/swapnetworks/ccl2.py
@@ -93,8 +93,10 @@ class TwoLocalSwapNetwork(Operation):
     @classmethod
     def _unflatten(cls, data, metadata):
         new_op = cls.__new__(cls)
-        new_op._hyperparameters = dict(metadata[1])  # pylint: disable=protected-access
-        new_op._weights = data[0]  # pylint: disable=protected-access
+        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+        # pylint: disable=protected-access
+        new_op._hyperparameters = dict(metadata[1])
+        new_op._weights = data[0]
         Operation.__init__(new_op, *data, wires=metadata[0])
         return new_op
 
diff --git a/pennylane/templates/tensornetworks/mera.py b/pennylane/templates/tensornetworks/mera.py
index c0acb79b6..56022347e 100644
--- a/pennylane/templates/tensornetworks/mera.py
+++ b/pennylane/templates/tensornetworks/mera.py
@@ -15,6 +15,9 @@
 Contains the MERA template.
 """
 # pylint: disable-msg=too-many-branches,too-many-arguments,protected-access
+
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=no-member, unused-argument
 import warnings
 from collections.abc import Callable
 
@@ -53,7 +56,7 @@ def compute_indices(wires, n_block_wires):
             f"got n_block_wires = {n_block_wires} and number of wires = {n_wires}"
         )
 
-    if not np.log2(n_wires / n_block_wires).is_integer():  # pylint:disable=no-member
+    if not np.log2(n_wires / n_block_wires).is_integer():
         warnings.warn(
             f"The number of wires should be n_block_wires times 2^n; got n_wires/n_block_wires = {n_wires/n_block_wires}"
         )
@@ -228,9 +231,7 @@ class MERA(Operation):
         super().__init__(template_weights, wires=wires, id=id)
 
     @staticmethod
-    def compute_decomposition(
-        weights, wires, block, ind_gates
-    ):  # pylint: disable=arguments-differ,unused-argument
+    def compute_decomposition(weights, wires, block, ind_gates):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators.
 
         .. math:: O = O_1 O_2 \dots O_n.
@@ -271,7 +272,7 @@ class MERA(Operation):
         """
 
         n_wires = len(wires)
-        if not np.log2(n_wires / n_block_wires).is_integer():  # pylint:disable=no-member
+        if not np.log2(n_wires / n_block_wires).is_integer():
             warnings.warn(
                 f"The number of wires should be n_block_wires times 2^n; got n_wires/n_block_wires = {n_wires/n_block_wires}"
             )
diff --git a/pennylane/templates/tensornetworks/mps.py b/pennylane/templates/tensornetworks/mps.py
index 8e2698c3b..d53db1054 100644
--- a/pennylane/templates/tensornetworks/mps.py
+++ b/pennylane/templates/tensornetworks/mps.py
@@ -231,10 +231,12 @@ class MPS(Operation):
         """int: Number of trainable parameters that the operator depends on."""
         return 0 if self._weights is None else 1
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=unused-argument
     @staticmethod
     def compute_decomposition(
         weights=None, wires=None, ind_gates=None, block=None, **kwargs
-    ):  # pylint: disable=arguments-differ,unused-argument
+    ):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators.
 
         .. math:: O = O_1 O_2 \dots O_n.
diff --git a/pennylane/templates/tensornetworks/ttn.py b/pennylane/templates/tensornetworks/ttn.py
index fd1d13d72..e7bec262c 100644
--- a/pennylane/templates/tensornetworks/ttn.py
+++ b/pennylane/templates/tensornetworks/ttn.py
@@ -15,6 +15,9 @@
 Contains the TTN template.
 """
 # pylint: disable-msg=too-many-branches,too-many-arguments,protected-access
+
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=no-member, unused-argument
 import warnings
 
 import numpy as np
@@ -52,7 +55,7 @@ def compute_indices(wires, n_block_wires):
             f"got n_block_wires = {n_block_wires} and number of wires = {n_wires}"
         )
 
-    if not np.log2(n_wires / n_block_wires).is_integer():  # pylint:disable=no-member
+    if not np.log2(n_wires / n_block_wires).is_integer():
         warnings.warn(
             f"The number of wires should be n_block_wires times 2^n; got n_wires/n_block_wires = {n_wires/n_block_wires}"
         )
@@ -199,9 +202,7 @@ class TTN(Operation):
         super().__init__(template_weights, wires=wires, id=id)
 
     @staticmethod
-    def compute_decomposition(
-        weights, wires, block, ind_gates
-    ):  # pylint: disable=arguments-differ,unused-argument
+    def compute_decomposition(weights, wires, block, ind_gates):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators.
 
         .. math:: O = O_1 O_2 \dots O_n.
@@ -244,7 +245,7 @@ class TTN(Operation):
         """
 
         n_wires = len(wires)
-        if not np.log2(n_wires / n_block_wires).is_integer():  # pylint:disable=no-member
+        if not np.log2(n_wires / n_block_wires).is_integer():
             warnings.warn(
                 f"The number of wires should be n_block_wires times 2^n; got n_wires/n_block_wires = {n_wires/n_block_wires}"
             )
diff --git a/pennylane/transforms/__init__.py b/pennylane/transforms/__init__.py
index e958d7610..a5a854133 100644
--- a/pennylane/transforms/__init__.py
+++ b/pennylane/transforms/__init__.py
@@ -115,6 +115,7 @@ preprocessing, getting information from a circuit, and more.
     ~transforms.add_noise
     ~defer_measurements
     ~transforms.diagonalize_measurements
+    ~transforms.set_shots
     ~transforms.split_non_commuting
     ~transforms.split_to_single_terms
     ~transforms.broadcast_expand
@@ -302,6 +303,7 @@ from .decompositions import clifford_t_decomposition
 from .defer_measurements import defer_measurements
 from .diagonalize_measurements import diagonalize_measurements
 from .dynamic_one_shot import dynamic_one_shot, is_mcm
+from .set_shots import set_shots
 from .sign_expand import sign_expand
 from .split_non_commuting import split_non_commuting
 from .split_to_single_terms import split_to_single_terms
diff --git a/pennylane/transforms/batch_input.py b/pennylane/transforms/batch_input.py
index 7a3f221dd..904838ac6 100644
--- a/pennylane/transforms/batch_input.py
+++ b/pennylane/transforms/batch_input.py
@@ -79,7 +79,7 @@ def batch_input(
     array([0.46230079, 0.73971315, 0.95666004, 0.5355225 , 0.66180948,
             0.44519553, 0.93874261, 0.9483197 , 0.78737918, 0.90866411])>
     """
-    # pylint: disable=protected-access
+
     argnum = tuple(argnum) if isinstance(argnum, (list, tuple)) else (int(argnum),)
 
     all_parameters = tape.get_parameters(trainable_only=False)
diff --git a/pennylane/transforms/batch_params.py b/pennylane/transforms/batch_params.py
index c2da381e3..c772aabc1 100644
--- a/pennylane/transforms/batch_params.py
+++ b/pennylane/transforms/batch_params.py
@@ -14,7 +14,7 @@
 """
 Contains the batch dimension transform.
 """
-# pylint: disable=import-outside-toplevel
+
 
 import pennylane as qml
 from pennylane.tape import QuantumScript, QuantumScriptBatch
@@ -28,6 +28,7 @@ def _nested_stack(res):
     Given a list of identical nested tuple structures, stack the arrays at the leaves
     """
     # for some reason pylint thinks qml.numpy.builtins is a dict
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
     # pylint: disable=no-member
     if not isinstance(res[0], (tuple, qml.numpy.builtins.SequenceBox)):
         return qml.math.stack(res)
@@ -56,7 +57,7 @@ def _split_operations(ops, params, split_indices, num_tapes):
         num_tapes (int): the number of new tapes to create, which is also equal to the batch size.
     """
     # for some reason pylint thinks "qml.ops" is a set
-    # pylint: disable=no-member
+
     new_ops = [[] for _ in range(num_tapes)]
     idx = 0
 
@@ -173,7 +174,7 @@ def batch_params(
     >>> qml.grad(cost_fn)(x, weights)[0]
     -0.30262974103192636
     """
-    # pylint: disable=protected-access
+
     params = tape.get_parameters(trainable_only=False)
     indices = list(range(len(params))) if all_operations else list(tape.trainable_params)
 
diff --git a/pennylane/transforms/broadcast_expand.py b/pennylane/transforms/broadcast_expand.py
index 2d5596c14..1b5067dc1 100644
--- a/pennylane/transforms/broadcast_expand.py
+++ b/pennylane/transforms/broadcast_expand.py
@@ -28,7 +28,7 @@ def _split_operations(ops, num_tapes):
     of new operators with length num_tapes, with the parameters split.
     """
     # for some reason pylint thinks "qml.ops" is a set
-    # pylint: disable=no-member
+
     new_ops = [[] for _ in range(num_tapes)]
     for op in ops:
         # determine if any parameters of the operator are batched
diff --git a/pennylane/transforms/compile.py b/pennylane/transforms/compile.py
index e0bf8c4c5..23d11d574 100644
--- a/pennylane/transforms/compile.py
+++ b/pennylane/transforms/compile.py
@@ -13,8 +13,6 @@
 # limitations under the License.
 """Code for the high-level quantum function transform that executes compilation."""
 from collections.abc import Sequence
-
-# pylint: disable=too-many-branches
 from functools import partial
 
 import pennylane as qml
diff --git a/pennylane/transforms/convert_to_numpy_parameters.py b/pennylane/transforms/convert_to_numpy_parameters.py
index ca04218f7..c4f54ef54 100644
--- a/pennylane/transforms/convert_to_numpy_parameters.py
+++ b/pennylane/transforms/convert_to_numpy_parameters.py
@@ -23,7 +23,6 @@ from pennylane.transforms import transform
 from pennylane.typing import PostprocessingFn
 
 
-# pylint: disable=no-member
 def _convert_op_to_numpy_data(op: qml.operation.Operator) -> qml.operation.Operator:
     if math.get_interface(*op.data) == "numpy":
         return op
@@ -31,7 +30,6 @@ def _convert_op_to_numpy_data(op: qml.operation.Operator) -> qml.operation.Opera
     return qml.ops.functions.bind_new_parameters(op, math.unwrap(op.data))
 
 
-# pylint: disable=no-member
 def _convert_measurement_to_numpy_data(
     m: qml.measurements.MeasurementProcess,
 ) -> qml.measurements.MeasurementProcess:
@@ -46,7 +44,6 @@ def _convert_measurement_to_numpy_data(
     return type(m)(obs=new_obs)
 
 
-# pylint: disable=protected-access
 @transform
 def convert_to_numpy_parameters(tape: QuantumScript) -> tuple[QuantumScriptBatch, PostprocessingFn]:
     """Transforms a circuit to one with purely numpy parameters.
diff --git a/pennylane/transforms/core/transform_dispatcher.py b/pennylane/transforms/core/transform_dispatcher.py
index 34363aee0..1e507df18 100644
--- a/pennylane/transforms/core/transform_dispatcher.py
+++ b/pennylane/transforms/core/transform_dispatcher.py
@@ -108,7 +108,7 @@ class TransformDispatcher:  # pylint: disable=too-many-instance-attributes
     .. seealso:: :func:`~.pennylane.transform`
     """
 
-    def __new__(cls, *args, **kwargs):  # pylint: disable=unused-argument
+    def __new__(cls, *args, **__):
         if os.environ.get("SPHINX_BUILD") == "1":
             # If called during a Sphinx documentation build,
             # simply return the original function rather than
@@ -137,7 +137,7 @@ class TransformDispatcher:  # pylint: disable=too-many-instance-attributes
         final_transform=False,
         use_argnum_in_expand=False,
         plxpr_transform=None,
-    ):  # pylint:disable=redefined-outer-name
+    ):
         self._transform = transform
         self._expand_transform = expand_transform
         self._classical_cotransform = classical_cotransform
@@ -475,7 +475,7 @@ class TransformDispatcher:  # pylint: disable=too-many-instance-attributes
         return tuple(execution_tapes), processing_fn
 
 
-class TransformContainer:  # pylint: disable=too-many-instance-attributes, too-many-positional-arguments
+class TransformContainer:  # pylint: disable=too-many-instance-attributes
     """Class to store a quantum transform with its ``args``, ``kwargs`` and classical co-transforms.  Use
     :func:`~.pennylane.transform`.
 
@@ -498,7 +498,7 @@ class TransformContainer:  # pylint: disable=too-many-instance-attributes, too-m
         is_informative=False,
         final_transform=False,
         use_argnum=False,
-    ):  # pylint:disable=redefined-outer-name,too-many-arguments,too-many-positional-arguments
+    ):  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self._transform = transform
         self._args = args or []
         self._kwargs = kwargs or {}
diff --git a/pennylane/transforms/core/transform_program.py b/pennylane/transforms/core/transform_program.py
index 16ed1b1eb..2f5da0179 100644
--- a/pennylane/transforms/core/transform_program.py
+++ b/pennylane/transforms/core/transform_program.py
@@ -511,7 +511,6 @@ class TransformProgram:
             i -= 1
         return found
 
-    # pylint: disable=too-many-arguments, too-many-positional-arguments
     def _get_classical_jacobian(self, index: int, tape_idx: int):
         if self.cotransform_cache is None or not self[index].classical_cotransform:
             return None
diff --git a/pennylane/transforms/decompose.py b/pennylane/transforms/decompose.py
index 698d7e9a8..2018f0794 100644
--- a/pennylane/transforms/decompose.py
+++ b/pennylane/transforms/decompose.py
@@ -15,7 +15,6 @@
 A transform for decomposing quantum circuits into user defined gate sets. Offers an alternative to the more device-focused decompose transform.
 """
 
-# pylint: disable=unnecessary-lambda-assignment,protected-access
 
 from __future__ import annotations
 
diff --git a/pennylane/transforms/decompositions/clifford_t_transform.py b/pennylane/transforms/decompositions/clifford_t_transform.py
index c1e14f780..b2d7d4adc 100644
--- a/pennylane/transforms/decompositions/clifford_t_transform.py
+++ b/pennylane/transforms/decompositions/clifford_t_transform.py
@@ -198,7 +198,7 @@ def _rot_decompose(op):
         return d_ops
 
     (theta,), wires = op.data, op.wires
-    if isinstance(op, qml.ops.Adjoint):  # pylint: disable=no-member
+    if isinstance(op, qml.ops.Adjoint):
         ops_ = _rot_decompose(op.base.adjoint())
     elif isinstance(op, qml.RX):
         ops_ = _simplify_param(theta, qml.X(wires))
@@ -330,7 +330,7 @@ def _merge_param_gates(operations, merge_ops=None):
     return merged_ops, number_ops
 
 
-# pylint: disable= too-many-nested-blocks, too-many-branches, too-many-statements, unnecessary-lambda-assignment
+# pylint: disable=too-many-branches
 @transform
 def clifford_t_decomposition(
     tape: QuantumScript,
diff --git a/pennylane/transforms/defer_measurements.py b/pennylane/transforms/defer_measurements.py
index d48e03404..3f1a4eb2e 100644
--- a/pennylane/transforms/defer_measurements.py
+++ b/pennylane/transforms/defer_measurements.py
@@ -129,7 +129,7 @@ def _get_plxpr_defer_measurements():
     class DeferMeasurementsInterpreter(PlxprInterpreter):
         """Interpreter for applying the defer_measurements transform to plxpr."""
 
-        # pylint: disable=unnecessary-lambda-assignment,attribute-defined-outside-init,no-self-use
+        # pylint: disable=attribute-defined-outside-init,no-self-use
 
         def __init__(self, num_wires):
             super().__init__()
@@ -391,9 +391,7 @@ def _get_plxpr_defer_measurements():
         return MeasurementValue([meas], lambda x: x)
 
     @DeferMeasurementsInterpreter.register_primitive(cond_prim)
-    def _(
-        self, *invals, jaxpr_branches, consts_slices, args_slice
-    ):  # pylint: disable=unused-argument
+    def _(self, *invals, jaxpr_branches, consts_slices, args_slice):
         n_branches = len(jaxpr_branches)
         conditions = invals[:n_branches]
         if not any(isinstance(c, MeasurementValue) for c in conditions):
diff --git a/pennylane/transforms/diagonalize_measurements.py b/pennylane/transforms/diagonalize_measurements.py
index 9ce3874e3..e5b8ad7f0 100644
--- a/pennylane/transforms/diagonalize_measurements.py
+++ b/pennylane/transforms/diagonalize_measurements.py
@@ -25,7 +25,7 @@ from pennylane.tape.tape import (
 )
 from pennylane.transforms.core import transform
 
-# pylint: disable=protected-access,unused-argument
+# pylint: disable=unused-argument
 
 _default_supported_obs = (qml.Z, qml.Identity)
 
diff --git a/pennylane/transforms/dynamic_one_shot.py b/pennylane/transforms/dynamic_one_shot.py
index 4328c21bd..a838a2b75 100644
--- a/pennylane/transforms/dynamic_one_shot.py
+++ b/pennylane/transforms/dynamic_one_shot.py
@@ -16,8 +16,6 @@ Contains the batch dimension transform.
 """
 
 import itertools
-
-# pylint: disable=import-outside-toplevel
 from collections import Counter
 from collections.abc import Sequence
 
@@ -237,7 +235,7 @@ def init_auxiliary_tape(circuit: qml.tape.QuantumScript):
     )
 
 
-# pylint: disable=too-many-branches,too-many-statements
+# pylint: disable=too-many-branches
 def parse_native_mid_circuit_measurements(
     circuit: qml.tape.QuantumScript,
     aux_tapes: qml.tape.QuantumScript,
diff --git a/pennylane/transforms/mitigate.py b/pennylane/transforms/mitigate.py
index 2d366d6e0..e22c76b5e 100644
--- a/pennylane/transforms/mitigate.py
+++ b/pennylane/transforms/mitigate.py
@@ -373,7 +373,7 @@ def exponential_extrapolate(x, y, asymptote=None, eps=1.0e-6):
     return sign * qml.math.exp(zne_unscaled) + asymptote
 
 
-# pylint: disable=too-many-arguments, protected-access
+# pylint: disable=too-many-arguments
 @transform
 def mitigate_with_zne(
     tape: QuantumScript,
diff --git a/pennylane/transforms/optimization/cancel_inverses.py b/pennylane/transforms/optimization/cancel_inverses.py
index e280ef883..68dc89111 100644
--- a/pennylane/transforms/optimization/cancel_inverses.py
+++ b/pennylane/transforms/optimization/cancel_inverses.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Transform for cancelling adjacent inverse gates in quantum circuits."""
-# pylint: disable=too-many-branches
+
 from functools import lru_cache, partial
 
 from pennylane.ops.op_math import Adjoint
@@ -65,7 +65,7 @@ def _are_inverses(op1, op2):
 
 
 @lru_cache
-def _get_plxpr_cancel_inverses():  # pylint: disable=missing-function-docstring,too-many-statements
+def _get_plxpr_cancel_inverses():  # pylint: disable=too-many-statements
     try:
         # pylint: disable=import-outside-toplevel
         from jax import make_jaxpr
@@ -186,7 +186,7 @@ def _get_plxpr_cancel_inverses():  # pylint: disable=missing-function-docstring,
                 list[TensorLike]: the results of the execution.
 
             """
-            # pylint: disable=too-many-branches,attribute-defined-outside-init
+            # pylint: disable=attribute-defined-outside-init
             self._env = {}
             self.setup()
 
diff --git a/pennylane/transforms/optimization/commute_controlled.py b/pennylane/transforms/optimization/commute_controlled.py
index d96ecfca1..6408332ea 100644
--- a/pennylane/transforms/optimization/commute_controlled.py
+++ b/pennylane/transforms/optimization/commute_controlled.py
@@ -28,7 +28,7 @@ from .optimization_utils import find_next_gate
 
 
 @lru_cache
-def _get_plxpr_commute_controlled():  # pylint: disable=missing-function-docstring,too-many-statements
+def _get_plxpr_commute_controlled():  # pylint: disable=too-many-statements
     try:
         # pylint: disable=import-outside-toplevel
         from jax import make_jaxpr
diff --git a/pennylane/transforms/optimization/merge_rotations.py b/pennylane/transforms/optimization/merge_rotations.py
index 4d4f52b03..048d7f339 100644
--- a/pennylane/transforms/optimization/merge_rotations.py
+++ b/pennylane/transforms/optimization/merge_rotations.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Transform for merging adjacent rotations of the same type in a quantum circuit."""
-# pylint: disable=too-many-branches
+
 
 from functools import lru_cache, partial
 from typing import Optional
@@ -42,7 +42,7 @@ def _get_plxpr_merge_rotations():
     except ImportError:  # pragma: no cover
         return None, None
 
-    # pylint: disable=redefined-outer-name, too-few-public-methods
+    # pylint: disable=redefined-outer-name
     class MergeRotationsInterpreter(PlxprInterpreter):
         """Plxpr Interpreter for applying the ``merge_rotations``
         transform when program capture is enabled."""
@@ -167,7 +167,7 @@ def _get_plxpr_merge_rotations():
                 list[TensorLike]: the results of the execution.
 
             """
-            # pylint: disable=too-many-branches,attribute-defined-outside-init
+            # pylint: disable=attribute-defined-outside-init
             self._env = {}
             self.setup()
 
diff --git a/pennylane/transforms/optimization/optimization_utils.py b/pennylane/transforms/optimization/optimization_utils.py
index dbc845234..c0b6683be 100644
--- a/pennylane/transforms/optimization/optimization_utils.py
+++ b/pennylane/transforms/optimization/optimization_utils.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Utility functions for circuit optimization."""
-# pylint: disable=too-many-return-statements,import-outside-toplevel
+
 import pennylane as qml
 from pennylane.ops.identity import GlobalPhase
 from pennylane.wires import Wires
diff --git a/pennylane/transforms/optimization/pattern_matching.py b/pennylane/transforms/optimization/pattern_matching.py
index 4dc168c95..e03afaa13 100644
--- a/pennylane/transforms/optimization/pattern_matching.py
+++ b/pennylane/transforms/optimization/pattern_matching.py
@@ -30,7 +30,6 @@ from pennylane.typing import PostprocessingFn
 from pennylane.wires import Wires
 
 
-# pylint: disable=too-many-statements
 @transform
 def pattern_matching_optimization(
     tape: QuantumScript, pattern_tapes, custom_quantum_cost=None
@@ -197,7 +196,7 @@ def pattern_matching_optimization(
     Exact and practical pattern matching for quantum circuit optimization.
     `doi.org/10.1145/3498325 <https://dl.acm.org/doi/abs/10.1145/3498325>`_
     """
-    # pylint: disable=too-many-branches
+
     consecutive_wires = Wires(range(len(tape.wires)))
     inverse_wires_map = OrderedDict(zip(consecutive_wires, tape.wires))
     original_tape_meas = tape.measurements
@@ -571,7 +570,7 @@ def _update_qubits(circuit_dag, qubits_conf):
         list(list(int)): Target wires
         list(list(int)): Control wires
     """
-    # pylint: disable=too-many-arguments
+
     wires = []
     control_wires = []
     target_wires = []
@@ -638,7 +637,7 @@ def _compare_qubits(node1, wires1, control1, target1, wires2, control2, target2)
         control2 (list(int)): Control wires of the second node.
         target2 (list(int)): Target wires of the second node.
     """
-    # pylint: disable=too-many-instance-attributes, too-many-arguments
+    # pylint: disable=too-many-arguments
 
     control_base = {
         "CNOT": "PauliX",
@@ -684,7 +683,7 @@ class ForwardMatch:  # pylint: disable=too-many-instance-attributes,too-few-publ
             node_id_c (int): index of the first gate matched in the circuit.
             node_id_p (int): index of the first gate matched in the pattern.
         """
-        # pylint: disable=too-many-branches, too-many-arguments
+        # pylint: disable=too-many-arguments
 
         # Commutation DAG of the circuit
         self.circuit_dag = circuit_dag
@@ -839,7 +838,7 @@ class ForwardMatch:  # pylint: disable=too-many-instance-attributes,too-few-publ
         """Apply the forward match algorithm and returns the list of matches given an initial match
         and a qubits configuration.
         """
-        # pylint: disable=too-many-branches,too-many-nested-blocks
+        # pylint: disable=too-many-nested-blocks
 
         # Initialization
         self._init_successors_to_visit()
diff --git a/pennylane/transforms/optimization/remove_barrier.py b/pennylane/transforms/optimization/remove_barrier.py
index 9e265730a..cb82e791d 100644
--- a/pennylane/transforms/optimization/remove_barrier.py
+++ b/pennylane/transforms/optimization/remove_barrier.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Transform for removing the Barrier gate from quantum circuits."""
-# pylint: disable=too-many-branches
+
 
 from pennylane.tape import QuantumScript, QuantumScriptBatch
 from pennylane.transforms import transform
diff --git a/pennylane/transforms/optimization/single_qubit_fusion.py b/pennylane/transforms/optimization/single_qubit_fusion.py
index 2d5a55bcb..3459002e6 100644
--- a/pennylane/transforms/optimization/single_qubit_fusion.py
+++ b/pennylane/transforms/optimization/single_qubit_fusion.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Transform for fusing sequences of single-qubit gates."""
-# pylint: disable=too-many-branches
+
 
 from functools import lru_cache, partial
 from typing import Optional
@@ -28,7 +28,7 @@ from .optimization_utils import find_next_gate, fuse_rot_angles
 
 
 @lru_cache
-def _get_plxpr_single_qubit_fusion():  # pylint: disable=missing-function-docstring,too-many-statements
+def _get_plxpr_single_qubit_fusion():  # pylint: disable=too-many-statements
     try:
         # pylint: disable=import-outside-toplevel
         from jax import make_jaxpr
diff --git a/pennylane/transforms/optimization/undo_swaps.py b/pennylane/transforms/optimization/undo_swaps.py
index f1ff23c7d..6664fa5ae 100644
--- a/pennylane/transforms/optimization/undo_swaps.py
+++ b/pennylane/transforms/optimization/undo_swaps.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 """Transform that eliminates the swap operators by reordering the wires."""
-# pylint: disable=too-many-branches
+
 
 from pennylane.tape import QuantumScript, QuantumScriptBatch
 from pennylane.transforms import transform
diff --git a/pennylane/transforms/set_shots.py b/pennylane/transforms/set_shots.py
new file mode 100644
index 000000000..81e61c9db
--- /dev/null
+++ b/pennylane/transforms/set_shots.py
@@ -0,0 +1,82 @@
+# Copyright 2025 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Contains the set_shots transform, which sets the number of shots for a given tape.
+"""
+from typing import Sequence, Union
+
+from pennylane.measurements import Shots
+from pennylane.tape import QuantumScript, QuantumScriptBatch
+from pennylane.transforms.core import transform
+from pennylane.typing import PostprocessingFn
+
+
+def null_postprocessing(results):
+    """An empty post-processing function."""
+    return results[0]
+
+
+@transform
+def set_shots(
+    tape: QuantumScript, shots: Union[Shots, None, int, Sequence[Union[int, tuple[int, int]]]]
+) -> tuple[QuantumScriptBatch, PostprocessingFn]:
+    """Transform used to set or update a circuit's shots.
+
+    Args:
+        tape (QuantumScript): The quantum circuit to be modified.
+        shots (None or int or Sequence[int] or Sequence[tuple[int, int]] or pennylane.shots.Shots): The
+            number of shots (or a shots vector) that the transformed circuit will execute.
+            This specification will override any shots value previously associated
+            with the circuit or QNode during execution.
+
+    Returns:
+        tuple[List[QuantumScript], function]: The transformed circuit as a batch of tapes and a
+        post-processing function, as described in :func:`qml.transform <pennylane.transform>`. The output
+        tape(s) will have their ``shots`` attribute set to the value provided in the ``shots`` argument.
+
+    There are three ways to specify shot values (see :func:`qml.measurements.Shots <pennylane.measurements.Shots>` for more details):
+
+    * The value ``None``: analytic mode, no shots
+    * A positive integer: a fixed number of shots
+    * A sequence consisting of either positive integers or a tuple-pair of positive integers of the form ``(shots, copies)``
+
+    **Examples**
+
+    Set the number of shots as a decorator:
+
+    .. code-block:: python
+
+        from functools import partial
+
+        @partial(qml.set_shots, shots=2)
+        @qml.qnode(qml.device("default.qubit", wires=1))
+        def circuit():
+            qml.RX(1.23, wires=0)
+            return qml.sample(qml.Z(0))
+
+    Run the circuit:
+
+    >>> circuit()
+    array([1., -1.])
+
+    Update the shots in-line for an existing circuit:
+
+    >>> new_circ = qml.set_shots(circuit, shots=(4, 10)) # shot vector
+    >>> new_circ()
+    (array([-1.,  1., -1.,  1.]), array([ 1.,  1.,  1., -1.,  1.,  1., -1., -1.,  1.,  1.]))
+
+    """
+    if tape.shots != Shots(shots):
+        tape = tape.copy(shots=shots)
+    return (tape,), null_postprocessing
diff --git a/pennylane/transforms/sign_expand/sign_expand.py b/pennylane/transforms/sign_expand/sign_expand.py
index dcb9ec504..0f94eb583 100644
--- a/pennylane/transforms/sign_expand/sign_expand.py
+++ b/pennylane/transforms/sign_expand/sign_expand.py
@@ -12,7 +12,7 @@
 """
 Contains the sign (and xi) decomposition tape transform, implementation of ideas from arXiv:2207.09479
 """
-# pylint: disable=protected-access
+
 import json
 from os import path
 
@@ -198,7 +198,7 @@ def construct_sgn_circuit(  # pylint: disable=too-many-arguments
 
 
 @transform
-def sign_expand(  # pylint: disable=too-many-arguments
+def sign_expand(
     tape: QuantumScript, circuit=False, J=10, delta=0.0, controls=("Hadamard", "Target")
 ) -> tuple[QuantumScriptBatch, PostprocessingFn]:
     r"""
@@ -330,13 +330,13 @@ def sign_expand(  # pylint: disable=too-many-arguments
     if circuit:
         tapes = construct_sgn_circuit(hamiltonian, tape, mus, times, phis, controls)
         if isinstance(tape.measurements[0], qml.measurements.ExpectationMP):
-            # pylint: disable=function-redefined
+
             def processing_fn(res):
                 products = [a * b for a, b in zip(res, dEs)]
                 return qml.math.sum(products)
 
         else:
-            # pylint: disable=function-redefined
+
             def processing_fn(res):
                 products = [a * b for a, b in zip(res, dEs)]
                 return qml.math.sum(products) * len(products)
diff --git a/pennylane/transforms/split_non_commuting.py b/pennylane/transforms/split_non_commuting.py
index ba2829622..fe4dea414 100644
--- a/pennylane/transforms/split_non_commuting.py
+++ b/pennylane/transforms/split_non_commuting.py
@@ -16,7 +16,7 @@
 Contains the tape transform that splits a tape into tapes measuring commuting observables.
 """
 
-# pylint: disable=too-many-arguments,too-many-boolean-expressions
+# pylint: disable=too-many-boolean-expressions
 
 from functools import partial, wraps
 from typing import Optional
@@ -557,6 +557,7 @@ def _split_all_multi_term_obs_mps(tape: qml.tape.QuantumScript):
                 # If the single-term measurement already exists, it can be reused by all original
                 # measurements. In this case, add the existing single-term measurement to the list
                 # corresponding to this original measurement.
+                # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
                 # pylint: disable=superfluous-parens
                 elif (sm := qml.expval(o)) in single_term_obs_mps:
                     single_term_obs_mps[sm][0].append(mp_idx)
diff --git a/pennylane/transforms/tape_expand.py b/pennylane/transforms/tape_expand.py
index 0eb6c262c..35e7e9706 100644
--- a/pennylane/transforms/tape_expand.py
+++ b/pennylane/transforms/tape_expand.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 """This module contains tape expansion functions and stopping criteria to
 generate such functions from."""
-# pylint: disable=unused-argument,invalid-unary-operand-type, unsupported-binary-operation, no-member
+# pylint: disable=unused-argument,invalid-unary-operand-type
 import contextlib
 import warnings
 
@@ -182,7 +182,6 @@ def create_expand_trainable_multipar(tape, use_tape_argnum=False):
     if not use_tape_argnum:
         return expand_trainable_multipar
 
-    # pylint: disable=protected-access
     trainable_par_info = [tape.par_info[i] for i in tape.trainable_params]
     trainable_ops = [info["op"] for info in trainable_par_info]
 
diff --git a/pennylane/transforms/transpile.py b/pennylane/transforms/transpile.py
index 23a734615..a164f9c65 100644
--- a/pennylane/transforms/transpile.py
+++ b/pennylane/transforms/transpile.py
@@ -201,7 +201,9 @@ def transpile(
             # for the shortest path between the two qubits in the connectivity graph. We then move the q2 into the
             # neighbourhood of q1 via swap operations.
             source_wire, dest_wire = op.wires
-            # pylint:disable=too-many-function-args
+
+            # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+            # pylint: disable=too-many-function-args
             shortest_path = nx.algorithms.shortest_path(coupling_graph, source_wire, dest_wire)
             path_length = len(shortest_path) - 1
             wires_to_swap = [shortest_path[(i - 1) : (i + 1)] for i in range(path_length, 1, -1)]
diff --git a/pennylane/transforms/zx/converter.py b/pennylane/transforms/zx/converter.py
index 56f017f65..8fdb50077 100644
--- a/pennylane/transforms/zx/converter.py
+++ b/pennylane/transforms/zx/converter.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Transforms for interacting with PyZX, framework for ZX calculus."""
-# pylint: disable=too-many-statements, too-many-branches, too-many-return-statements, too-many-arguments
+# pylint: disable=too-many-return-statements,too-many-arguments
 
 from collections import OrderedDict
 from fractions import Fraction
@@ -52,7 +52,7 @@ class EdgeType:  # pylint: disable=too-few-public-methods
     HADAMARD = 2
 
 
-def to_zx(tape, expand_measurements=False):  # pylint: disable=unused-argument
+def to_zx(tape, expand_measurements=False):
     """This transform converts a PennyLane quantum tape to a ZX-Graph in the `PyZX framework <https://pyzx.readthedocs.io/en/latest/>`_.
     The graph can be optimized and transformed by well-known ZX-calculus reductions.
 
diff --git a/pennylane/typing.py b/pennylane/typing.py
index 9094a418f..1aa326e97 100644
--- a/pennylane/typing.py
+++ b/pennylane/typing.py
@@ -14,7 +14,7 @@
 """This file contains different PennyLane types."""
 import contextlib
 
-# pylint: disable=import-outside-toplevel, too-few-public-methods, unused-import
+# pylint: disable=import-outside-toplevel,too-few-public-methods
 import sys
 from collections.abc import Callable, Sequence
 from typing import TypeVar, Union
@@ -87,7 +87,7 @@ def _is_jax(other, subclass=False):
                     jax.Array  # TODO: keep this after jax>=0.4 is required
                     if hasattr(jax, "Array")
                     else Union[jaxlib.xla_extension.DeviceArray, jax.core.Tracer]
-                ),  # pylint: disable=c-extension-no-member
+                ),
             ]
             check = issubclass if subclass else isinstance
 
diff --git a/pennylane/workflow/_capture_qnode.py b/pennylane/workflow/_capture_qnode.py
index f77c3e9ba..eca4324a9 100644
--- a/pennylane/workflow/_capture_qnode.py
+++ b/pennylane/workflow/_capture_qnode.py
@@ -158,7 +158,7 @@ def _get_batch_shape(non_const_args, non_const_batch_dims):
 def _get_shapes_for(*measurements, shots=None, num_device_wires=0, batch_shape=()):
     """Calculate the abstract output shapes for the given measurements."""
 
-    if jax.config.jax_enable_x64:  # pylint: disable=no-member
+    if jax.config.jax_enable_x64:
         dtype_map = {
             float: jax.numpy.float64,
             int: jax.numpy.int64,
@@ -188,7 +188,7 @@ qnode_prim.multiple_results = True
 qnode_prim.prim_type = "higher_order"
 
 
-# pylint: disable=too-many-arguments, unused-argument
+# pylint: disable=too-many-arguments
 @debug_logger
 @qnode_prim.def_impl
 def _(*args, qnode, shots, device, execution_config, qfunc_jaxpr, n_consts, batch_dims=None):
@@ -567,7 +567,6 @@ def capture_qnode(qnode: "qml.QNode", *args, **kwargs) -> "qml.typing.Result":
     abstracted_axes, abstract_shapes = qml.capture.determine_abstracted_axes(flat_dynamic_args)
     cache_key = _get_jaxpr_cache_key(flat_dynamic_args, flat_static_args, kwargs, abstracted_axes)
 
-    # pylint: disable=protected-access
     if cached_value := qnode.capture_cache.get(cache_key, None):
         qfunc_jaxpr, config, out_tree = cached_value
     else:
diff --git a/pennylane/workflow/_setup_transform_program.py b/pennylane/workflow/_setup_transform_program.py
index d0d7c2a65..ffa570227 100644
--- a/pennylane/workflow/_setup_transform_program.py
+++ b/pennylane/workflow/_setup_transform_program.py
@@ -24,7 +24,6 @@ from pennylane.transforms.core import TransformProgram
 from ._cache_transform import _cache_transform
 
 
-# pylint: disable=protected-access
 def _prune_dynamic_transform(outer_transform, inner_transform):
     """Ensure a single ``dynamic_one_shot`` transform is applied.
 
diff --git a/pennylane/workflow/construct_batch.py b/pennylane/workflow/construct_batch.py
index b362dc415..d8c5ee4c3 100644
--- a/pennylane/workflow/construct_batch.py
+++ b/pennylane/workflow/construct_batch.py
@@ -329,7 +329,6 @@ def construct_batch(
 
     """
 
-    # pylint: disable=protected-access
     def batch_constructor(*args, **kwargs) -> tuple[QuantumScriptBatch, PostprocessingFn]:
         """Create a batch of tapes and a post processing function."""
         if "shots" in inspect.signature(qnode.func).parameters:
diff --git a/pennylane/workflow/interfaces/autograd.py b/pennylane/workflow/interfaces/autograd.py
index f38132f78..788ed099f 100644
--- a/pennylane/workflow/interfaces/autograd.py
+++ b/pennylane/workflow/interfaces/autograd.py
@@ -81,7 +81,7 @@ by the ``cache_full_jacobian`` keyword argument to :class:`~.TransformJacobianPr
 Other interfaces are capable of calculating the full jacobian in one call, so this patch is only present for autograd.
 
 """
-# pylint: disable=too-many-arguments, unused-argument
+
 import logging
 from collections.abc import Callable
 
@@ -139,7 +139,7 @@ def autograd_execute(
         params = tape.get_parameters(trainable_only=False)
         tape.trainable_params = qml.math.get_trainable_indices(params)
 
-    # pylint misidentifies autograd.builtins as a dict
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
     # pylint: disable=no-member
     parameters = autograd.builtins.tuple(
         [autograd.builtins.list(t.get_parameters()) for t in tapes]
@@ -156,6 +156,7 @@ def _to_autograd(result: qml.typing.ResultBatch) -> qml.typing.ResultBatch:
     """
     if isinstance(result, dict):
         return result
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
     # pylint: disable=no-member
     if isinstance(result, (list, tuple, autograd.builtins.tuple, autograd.builtins.list)):
         return tuple(_to_autograd(r) for r in result)
@@ -168,7 +169,7 @@ def _execute(
     tapes,
     execute_fn,
     jpc,
-):  # pylint: disable=unused-argument
+):
     """Autodifferentiable wrapper around a way of executing tapes.
 
     Args:
diff --git a/pennylane/workflow/interfaces/jax_jit.py b/pennylane/workflow/interfaces/jax_jit.py
index 8ed4cbaf8..97df4197c 100644
--- a/pennylane/workflow/interfaces/jax_jit.py
+++ b/pennylane/workflow/interfaces/jax_jit.py
@@ -35,7 +35,7 @@ Array(1., dtype=float64)
 Note that we must provide the expected output shape for the function to use pure callbacks.
 
 """
-# pylint: disable=unused-argument, too-many-arguments, protected-access
+# pylint: disable=unused-argument,too-many-arguments
 from functools import partial
 
 import jax
@@ -75,7 +75,6 @@ def _set_trainable_parameters_on_copy(tapes, params):
     return tuple(t.bind_new_parameters(a, t.trainable_params) for t, a in zip(tapes, params))
 
 
-# pylint: disable=no-member
 def _jax_dtype(m_type):
     if m_type == int:
         return jnp.int64 if jax.config.jax_enable_x64 else jnp.int32
diff --git a/pennylane/workflow/interfaces/tensorflow_autograph.py b/pennylane/workflow/interfaces/tensorflow_autograph.py
index e2a5ae8bc..01b2e96c2 100644
--- a/pennylane/workflow/interfaces/tensorflow_autograph.py
+++ b/pennylane/workflow/interfaces/tensorflow_autograph.py
@@ -15,7 +15,7 @@
 This module contains functions for adding the TensorFlow Autograph interface
 to a PennyLane Device class.
 """
-# pylint: disable=too-many-arguments,too-many-branches,too-many-statements
+# pylint: disable=too-many-arguments,too-many-statements
 from functools import reduce
 
 import numpy as np
@@ -202,7 +202,7 @@ def execute(
         return res + jacs + output_sizes
 
     @tf.custom_gradient
-    def _execute(*all_params):  # pylint:disable=unused-argument
+    def _execute(*all_params):
         res = tf.numpy_function(func=_forward, inp=all_params, Tout=output_types)
         output_sizes = res[-total_measurements * num_shot_copies :]
 
diff --git a/pennylane/workflow/interfaces/torch.py b/pennylane/workflow/interfaces/torch.py
index d6f3c3dea..5b0fb15ae 100644
--- a/pennylane/workflow/interfaces/torch.py
+++ b/pennylane/workflow/interfaces/torch.py
@@ -59,7 +59,7 @@ modifies the output of ``forward`` and the input to ``backward`` to unpack and r
 result object.
 
 """
-# pylint: disable=too-many-arguments,protected-access,abstract-method,unused-argument
+# pylint: disable=protected-access
 import inspect
 import logging
 
@@ -114,6 +114,8 @@ def _recursive_conj(dy):
     return tuple(_recursive_conj(d) for d in dy)
 
 
+# TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+# pylint: disable=abstract-method
 @pytreeify
 class ExecuteTapes(torch.autograd.Function):
     """The signature of this ``torch.autograd.Function`` is designed to
@@ -138,8 +140,10 @@ class ExecuteTapes(torch.autograd.Function):
 
     """
 
+    # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+    # pylint: disable=arguments-differ
     @staticmethod
-    def forward(ctx, kwargs, *parameters):  # pylint: disable=arguments-differ
+    def forward(ctx, kwargs, *parameters):
         """Implements the forward pass batch tape evaluation."""
         if logger.isEnabledFor(logging.DEBUG):
             logger.debug(
diff --git a/pennylane/workflow/qnode.py b/pennylane/workflow/qnode.py
index 9e7c93870..3f6a1e414 100644
--- a/pennylane/workflow/qnode.py
+++ b/pennylane/workflow/qnode.py
@@ -653,7 +653,7 @@ class QNode:
         copied_qnode.execute_kwargs = dict(self.execute_kwargs)
         copied_qnode._transform_program = qml.transforms.core.TransformProgram(
             self.transform_program
-        )  # pylint: disable=protected-access
+        )
         copied_qnode.gradient_kwargs = dict(self.gradient_kwargs)
         return copied_qnode
 
diff --git a/pennylane/workflow/run.py b/pennylane/workflow/run.py
index 8662b1bc3..792ec17d5 100644
--- a/pennylane/workflow/run.py
+++ b/pennylane/workflow/run.py
@@ -298,8 +298,9 @@ def run(
             config,
             differentiable=config.derivative_order > 1,
         )
-
-        results = ml_execute(  # pylint: disable=too-many-function-args, unexpected-keyword-arg
+        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+        # pylint: disable=unexpected-keyword-arg, too-many-function-args
+        results = ml_execute(
             tapes,
             device,
             execute_fn,


Test patch:
diff --git a/pennylane/devices/tests/__init__.py b/pennylane/devices/tests/__init__.py
index e7b3f68e0..71204712b 100644
--- a/pennylane/devices/tests/__init__.py
+++ b/pennylane/devices/tests/__init__.py
@@ -72,7 +72,7 @@ For more details on the available arguments, see the :func:`~.test_device` docum
 Functions
 ---------
 """
-# pylint: disable=import-outside-toplevel,too-many-arguments
+# pylint: disable=import-outside-toplevel
 import argparse
 import pathlib
 import subprocess
diff --git a/pennylane/devices/tests/conftest.py b/pennylane/devices/tests/conftest.py
index 56aa0640e..465a034d7 100755
--- a/pennylane/devices/tests/conftest.py
+++ b/pennylane/devices/tests/conftest.py
@@ -172,8 +172,6 @@ class StoreDictKeyPair(argparse.Action):
 
     """
 
-    # pylint: disable=too-few-public-methods
-
     def __init__(self, option_strings, dest, nargs=None, **kwargs):
         self._nargs = nargs
         super().__init__(option_strings, dest, nargs=nargs, **kwargs)
diff --git a/pennylane/devices/tests/test_compare_default_qubit.py b/pennylane/devices/tests/test_compare_default_qubit.py
index e7b10eea2..c1d654af7 100755
--- a/pennylane/devices/tests/test_compare_default_qubit.py
+++ b/pennylane/devices/tests/test_compare_default_qubit.py
@@ -14,7 +14,7 @@
 """Tests that a device gives the same output as the default device."""
 import numpy as np
 
-# pylint: disable=no-self-use,no-member
+# pylint: disable=no-self-use
 import pytest
 from flaky import flaky
 
@@ -252,6 +252,8 @@ class TestComparison:
 
         layers = 3
         rng = pnp.random.default_rng(1967)
+        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
+        # pylint: disable=no-member
         gates_per_layers = [rng.permutation(gates).numpy() for _ in range(layers)]
 
         def circuit():
diff --git a/pennylane/devices/tests/test_gates.py b/pennylane/devices/tests/test_gates.py
index cbe5fe0aa..4549893ea 100644
--- a/pennylane/devices/tests/test_gates.py
+++ b/pennylane/devices/tests/test_gates.py
@@ -17,9 +17,9 @@ works correctly an a device.
 """
 # pylint: disable=no-self-use
 # pylint: disable=too-many-arguments
-# pylint: disable=pointless-statement
+
 # pylint: disable=unnecessary-lambda-assignment
-# pylint: disable=no-name-in-module
+
 from cmath import exp
 from math import cos, sin, sqrt
 
@@ -121,7 +121,7 @@ all_ops = ops.keys()
 
 # All qubit operations should be available to test in the device test suite
 # Linting check disabled as static analysis can misidentify qml.ops as the set instance qml.ops.qubit.ops
-all_available_ops = qml.ops._qubit__ops__.copy()  # pylint: disable=protected-access,no-member
+all_available_ops = qml.ops._qubit__ops__.copy()  # pylint: disable=protected-access
 all_available_ops.remove("CPhase")  # CPhase is an alias of ControlledPhaseShift
 all_available_ops.remove("SQISW")  # SQISW is an alias of SISWAP
 all_available_ops.add("QFT")  # QFT was recently moved to being a template, but let's keep it here
@@ -592,7 +592,7 @@ class TestGatesQubit:
         res = benchmark(circuit)
 
         # Disabling Pylint test because qml.ops can be misunderstood as qml.ops.qubit.ops
-        basis_fn = qml.ops.qubit.special_unitary.pauli_basis_matrices  # pylint: disable=no-member
+        basis_fn = qml.ops.qubit.special_unitary.pauli_basis_matrices
         basis = basis_fn(n_wires)
         mat = qml.math.expm(1j * np.tensordot(theta_, basis, axes=[[0], [0]]))
         expected = np.abs(mat @ rnd_state) ** 2
diff --git a/pennylane/devices/tests/test_gates_with_expval.py b/pennylane/devices/tests/test_gates_with_expval.py
index f2e7e8951..359ec0ed9 100755
--- a/pennylane/devices/tests/test_gates_with_expval.py
+++ b/pennylane/devices/tests/test_gates_with_expval.py
@@ -17,7 +17,7 @@ device by checking expectation values.
 """
 # pylint: disable=no-self-use
 # pylint: disable=too-many-arguments
-# pylint: disable=pointless-statement
+
 from math import pi, sqrt
 
 import numpy as np
diff --git a/pennylane/devices/tests/test_measurements.py b/pennylane/devices/tests/test_measurements.py
index fe843efc8..0cd9d7297 100644
--- a/pennylane/devices/tests/test_measurements.py
+++ b/pennylane/devices/tests/test_measurements.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Tests that the different measurement types work correctly on a device."""
-# pylint: disable=no-self-use,pointless-statement, no-member
+# pylint: disable=no-self-use,no-member
 import pytest
 from flaky import flaky
 from scipy.sparse import csr_matrix
diff --git a/pennylane/devices/tests/test_properties.py b/pennylane/devices/tests/test_properties.py
index 4f0da4901..176a6c8a3 100755
--- a/pennylane/devices/tests/test_properties.py
+++ b/pennylane/devices/tests/test_properties.py
@@ -323,4 +323,4 @@ class TestCapabilities:
                 assert pnp.array(dev.access_state()).shape == orig_shape
 
         assert pnp.ndim(res) == 2
-        assert res.shape[0] == 3  # pylint:disable=unsubscriptable-object
+        assert res.shape[0] == 3
diff --git a/pennylane/devices/tests/test_return_system.py b/pennylane/devices/tests/test_return_system.py
index ed0aec266..a0fa9cb0b 100644
--- a/pennylane/devices/tests/test_return_system.py
+++ b/pennylane/devices/tests/test_return_system.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Tests that a device gives the correct output for multiple measurement."""
-# pylint: disable=no-self-use,no-member,redefined-outer-name
+# pylint: disable=no-self-use
 import pytest
 
 import pennylane as qml
diff --git a/pennylane/devices/tests/test_tracker.py b/pennylane/devices/tests/test_tracker.py
index 52f7b8619..7290fdcdf 100644
--- a/pennylane/devices/tests/test_tracker.py
+++ b/pennylane/devices/tests/test_tracker.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Tests that the device uses a tracker properly if it is supported."""
-# pylint: disable=no-self-use,no-member
+# pylint: disable=no-self-use
 import pytest
 
 import pennylane as qml
diff --git a/pennylane/devices/tests/test_wires.py b/pennylane/devices/tests/test_wires.py
index bdfac3795..625303b50 100644
--- a/pennylane/devices/tests/test_wires.py
+++ b/pennylane/devices/tests/test_wires.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Tests that a device has the right attributes, arguments and methods."""
-# pylint: disable=no-self-use,too-many-arguments,too-few-public-methods
+# pylint: disable=no-self-use
 import pytest
 
 import pennylane as qml
diff --git a/tests/transforms/test_set_shots.py b/tests/transforms/test_set_shots.py
new file mode 100644
index 000000000..540b82755
--- /dev/null
+++ b/tests/transforms/test_set_shots.py
@@ -0,0 +1,133 @@
+# Copyright 2025 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Unit tests for the ``set_shots`` transformer"""
+
+import pytest
+
+import pennylane as qml
+from pennylane.tape import QuantumScript
+from pennylane.transforms.set_shots import null_postprocessing, set_shots
+
+
+class TestSetShots:
+    """Unit tests for the set_shots preprocessing transform."""
+
+    def test_no_change(self):
+        """Test that set_shots returns a tape with the same shots if unchanged."""
+        tape = QuantumScript([qml.Hadamard(0)], [qml.expval(qml.PauliZ(0))], shots=10)
+        batch, post_fn = set_shots(tape, 10)
+        assert batch[0] is not None
+        assert batch[0].shots.total_shots == 10
+        assert tape.shots.total_shots == 10
+        assert batch[0].operations == tape.operations
+        assert batch[0].measurements == tape.measurements
+        assert post_fn == null_postprocessing
+        assert post_fn(batch) == batch[0]
+
+    def test_changes_shots(self):
+        """Test that set_shots returns a new tape with updated shots."""
+        tape = QuantumScript([qml.Hadamard(0)], [qml.expval(qml.PauliZ(0))], shots=5)
+        batch, post_fn = set_shots(tape, 20)
+        new_tape = batch[0]
+        assert new_tape is not tape
+        assert new_tape.shots.total_shots == 20
+        assert tape.shots.total_shots == 5
+        assert new_tape.operations == tape.operations
+        assert new_tape.measurements == tape.measurements
+        assert post_fn == null_postprocessing
+
+    def test_none_to_int(self):
+        """Test that set_shots can set shots from None to an integer."""
+        tape = QuantumScript([qml.PauliX(0)], [qml.probs(0)], shots=None)
+        batch, _ = set_shots(tape, 100)
+        assert batch[0].shots.total_shots == 100
+
+    def test_int_to_none(self):
+        """Test that set_shots can set shots from an integer to None."""
+        tape = QuantumScript([qml.PauliX(0)], [qml.probs(0)], shots=50)
+        batch, _ = set_shots(tape, None)
+        assert batch[0].shots.total_shots is None
+
+    def test_preserves_measurements_and_ops(self):
+        """Test that set_shots preserves operations and measurements."""
+        ops = [qml.RX(0.1, 0), qml.CNOT([0, 1])]
+        measurements = [qml.expval(qml.PauliZ(1)), qml.probs(0)]
+        tape = QuantumScript(ops, measurements, shots=5)
+        batch, _ = set_shots(tape, 10)
+        new_tape = batch[0]
+        assert new_tape.operations == ops
+        assert new_tape.measurements == measurements
+
+    @pytest.mark.integration
+    def test_circuit_specification(self):
+        """Test that a handy shot specification works."""
+
+        @qml.qnode(qml.device("default.qubit", wires=1))
+        def circuit():
+            qml.RX(1.23, wires=0)
+            return qml.sample(qml.Z(0))
+
+        res = circuit(shots=10)
+        assert len(res) == 10
+
+    @pytest.mark.integration
+    def test_circuit_shots_overridden_correctly(self):
+        """Test using a tracker to ensure that the shots in a circuit are overridden correctly.
+
+        We should have situations where:
+
+        1. device originally has finite shots and we override it with None
+        2. device originally is analytic and we override with finite shots.
+
+        """
+
+        dev = qml.device("default.qubit", wires=1, shots=10)
+
+        @qml.qnode(dev, diff_method=None)
+        def circuit():
+            qml.RX(1.23, wires=0)
+            return qml.probs(wires=0)
+
+        # 1. Device originally has finite shots, override with None
+        with qml.Tracker(dev) as tracker:
+            circuit()
+        assert tracker.history["shots"][-1] == 10
+
+        new_circuit = set_shots(circuit, shots=None)
+        with qml.Tracker(dev) as tracker:
+            new_circuit()
+        assert not "shots" in tracker.history
+
+    @pytest.mark.integration
+    def test_override_none_with_finite_shots(self):
+        """Test that we can override an analytic device with finite shots."""
+
+        # 2. Device originally is analytic, override with finite shots
+        dev = qml.device("default.qubit", wires=1, shots=None)
+
+        # pylint: disable=function-redefined
+        @qml.qnode(dev, diff_method=None)
+        def circuit():
+            qml.RX(1.23, wires=0)
+            return qml.probs(wires=0)
+
+        with qml.Tracker(dev) as tracker:
+            circuit()
+        assert not "shots" in tracker.history
+
+        new_circuit = set_shots(circuit, shots=20)
+        with qml.Tracker(dev) as tracker:
+            new_circuit()
+        assert tracker.history["shots"][-1] == 20