Remove top-level access to Device, QubitDevice and QutritDevice

doc/development/deprecations.rst

@@ -43,13 +43,6 @@ Pending deprecations
   - Deprecated in v0.39
   - Will be removed in v0.40
 
-* ``Device``, ``QubitDevice``, and ``QutritDevice`` will no longer be imported top level in v0.40.  They instead
-  will be available as ``qml.devices.LegacyDevice``, ``qml.devices.QubitDevice``, and ``qml.devices.QutritDevice``
-  respectively.
-
-  - Deprecated top level access in v0.39
-  - Top level access will be removed in v0.40
-
 * ``QNode.gradient_fn`` is deprecated. Please use ``QNode.diff_method`` instead. ``QNode.get_gradient_fn`` can also be used to
   process the diff method.
 
@@ -123,6 +116,13 @@ Other deprecations
 Completed deprecation cycles
 ----------------------------
 
+* Top level access to ``Device``, ``QubitDevice``, and ``QutritDevice`` have been removed. Instead, they
+  are available as ``qml.devices.LegacyDevice``, ``qml.devices.QubitDevice``, and ``qml.devices.QutritDevice``
+  respectively.
+
+  - Deprecated in v0.39
+  - Removed in v0.40
+
 * The ``simplify`` argument in ``qml.Hamiltonian`` and ``qml.ops.LinearCombination`` has been removed.
   Instead, ``qml.simplify()`` can be called on the constructed operator.
 

doc/development/guide/architecture.rst

@@ -168,7 +168,7 @@ Devices
 *******
 
 In PennyLane, the abstraction of a quantum computation device is encompassed
-within the :class:`pennylane.Device` class. The main job of devices is to
+within the :class:`pennylane.devices.LegacyDevice` class. The main job of devices is to
 interpret and execute tapes. The most important method is ``batch_execute``,
 which executes a list of tapes, such as a list of the single tape created above:
 

doc/development/legacy_plugins.rst

@@ -107,7 +107,7 @@ as well as potential further capabilities, by providing the following class attr
               return obj.name in {'CNOT', 'PauliX', 'PauliY', 'PauliZ'}
           return qml.BooleanFn(accepts_obj)
 
-  Supported operations can also be determined by the :attr:`pennylane.Device.operations` property.
+  Supported operations can also be determined by the :attr:`pennylane.devices.LegacyDevice.operations` property.
   This property is a list of string names for supported operations.
 
   .. code-block:: python
@@ -422,7 +422,7 @@ and similar code in the ``batch_execute`` method:
     self.tracker.update(batches=1, batch_len=len(circuits))
     self.tracker.record()
 
-These functions are called in base :class:`pennylane.Device` and :class:`~.QubitDevice` devices. Unless you are
+These functions are called in base :class:`pennylane.devices.LegacyDevice` and :class:`~.QubitDevice` devices. Unless you are
 overriding the ``execute`` and ``batch_execute`` methods or want to customize the stored
 information, you do not need to add any new code.
 

doc/introduction/circuits.rst

@@ -79,7 +79,7 @@ Defining a device
 
 To run---and later optimize---a quantum circuit, one needs to first specify a *computational device*.
 
-The device is an instance of the :class:`~.pennylane.Device`
+The device is an instance of the :class:`~.pennylane.devices.LegacyDevice`
 class, and can represent either a simulator or hardware device. They can be
 instantiated using the :func:`device <pennylane.device>` loader.
 

doc/releases/changelog-dev.md

@@ -52,6 +52,10 @@
 
 <h3>Breaking changes 💔</h3>
 
+* Top level access to `Device`, `QubitDevice`, and `QutritDevice` have been removed. Instead, they
+  are available as `qml.devices.LegacyDevice`, `qml.devices.QubitDevice`, and `qml.devices.QutritDevice`
+  respectively.
+
 <h3>Deprecations 👋</h3>
 
 <h3>Documentation 📝</h3>
@@ -68,7 +72,7 @@
 
 This release contains contributions from (in alphabetical order):
 
-Shiwen An
+Shiwen An,
 Astral Cai,
 Yushao Chen,
 Pietropaolo Frisoni,

pennylane/__init__.py

@@ -178,35 +178,10 @@
     if name == "plugin_devices":
         return pennylane.devices.device_constructor.plugin_devices
 
-    from warnings import warn  # pylint: disable=import-outside-toplevel
-
-    if name == "QubitDevice":
-        warn(
-            "QubitDevice will no longer be accessible top level. Please access "
-            "the class as pennylane.devices.QubitDevice",
-            PennyLaneDeprecationWarning,
-        )
-        return pennylane.devices._qubit_device.QubitDevice  # pylint:disable=protected-access
-
-    if name == "QutritDevice":
-        warn(
-            "QutritDevice will no longer be accessible top level. Please access "
-            "the class as pennylane.devices.QutritDevice",
-            PennyLaneDeprecationWarning,
-        )
-        return pennylane.devices._qutrit_device.QutritDevice  # pylint:disable=protected-access
-
-    if name == "Device":
-        warn(
-            "Device will no longer be accessible top level. Please access "
-            "the class as pennylane.devices.LegacyDevice",
-            PennyLaneDeprecationWarning,
-        )
-        return pennylane.devices._legacy_device.Device  # pylint:disable=protected-access
-
     raise AttributeError(f"module 'pennylane' has no attribute '{name}'")
 
 
 def version():
     """Returns the PennyLane version number."""
     return __version__
+

pennylane/devices/__init__.py

@@ -45,7 +45,7 @@
 :class:`pennylane.devices.Device` is the latest interface for the next generation of devices that
 replaces :class:`pennylane.Device` and :class:`pennylane.QubitDevice`.
 
-While the previous interface :class:`pennylane.Device` is imported top level, the new :class:`pennylane.devices.Device` is
+The previous interface :class:`pennylane.Device` has been removed from the top level, and the new :class:`pennylane.devices.Device` is
 accessible from the ``pennylane.devices`` submodule.
 
 .. currentmodule:: pennylane.devices

pennylane/devices/default_mixed.py

@@ -14,7 +14,7 @@
 r"""
 The default.mixed device is PennyLane's standard qubit simulator for mixed-state computations.
 
-It implements the necessary :class:`~pennylane.Device` methods as well as some built-in
+It implements the necessary :class:`~pennylane.devices.LegacyDevice` methods as well as some built-in
 qubit :doc:`operations </introduction/operations>`, providing a simple mixed-state simulation of
 qubit-based quantum circuits.
 """

pennylane/devices/device_api.py

@@ -57,7 +57,7 @@ class Device(abc.ABC):
     .. details::
         :title: Porting from the old interface
 
-        :meth:`pennylane.Device.batch_execute` and :meth:`~pennylane.Device.execute` are now a single method, :meth:`~.Device.execute`
+        :meth:`pennylane.devices.LegacyDevice.batch_execute` and :meth:`~pennylane.devices.LegacyDevice.execute` are now a single method, :meth:`~.Device.execute`
 
         :meth:`~.Device.batch_transform` and :meth:`~.Device.expand_fn` are now a single method, :meth:`~.Device.preprocess`
 

pennylane/gradients/parameter_shift_cv.py

@@ -538,7 +538,7 @@ def param_shift_cv(
 
     Args:
         tape (QNode or QuantumTape): quantum circuit to differentiate
-        dev (pennylane.Device): device the parameter-shift method is to be computed on
+        dev (pennylane.devices.LegacyDevice): device the parameter-shift method is to be computed on
         argnum (int or list[int] or None): Trainable parameter indices to differentiate
             with respect to. If not provided, the derivative with respect to all
             trainable indices are returned.

pennylane/measurements/classical_shadow.py

@@ -274,7 +274,7 @@ def process(self, tape, device):
 
         Args:
             tape (QuantumTape): the quantum tape to be processed
-            device (pennylane.Device): the device used to process the quantum tape
+            device (pennylane.devices.LegacyDevice): the device used to process the quantum tape
 
         Returns:
             tensor_like[int]: A tensor with shape ``(2, T, n)``, where the first row represents

pennylane/measurements/measurements.py

@@ -676,7 +676,7 @@ class MeasurementTransform(MeasurementProcess):
     which should have the following arguments:
 
     * tape (QuantumTape): quantum tape to transform
-    * device (pennylane.Device): device used to transform the quantum tape
+    * device (pennylane.devices.LegacyDevice): device used to transform the quantum tape
     """
 
     @abstractmethod
@@ -685,5 +685,5 @@ def process(self, tape, device):
 
         Args:
             tape (QuantumTape): quantum tape to transform
-            device (pennylane.Device): device used to transform the quantum tape
+            device (pennylane.devices.LegacyDevice): device used to transform the quantum tape
         """

pennylane/qcut/utils.py

@@ -203,7 +203,7 @@ def find_and_place_cuts(
     device, a :class:`~.CutStrategy` can be used to populate the necessary explorations of cutting
     parameters. As an extreme example, if the only device at our disposal is a 2-qubit device, a
     simple cut strategy is to simply specify the the ``max_free_wires`` argument (or equivalently
-    directly passing a :class:`pennylane.Device` to the ``device`` argument):
+    directly passing a :class:`pennylane.devices.LegacyDevice` to the ``device`` argument):
 
     >>> cut_strategy = qml.qcut.CutStrategy(max_free_wires=2)
     >>> cut_strategy.get_cut_kwargs(graph)

pennylane/transforms/defer_measurements.py

@@ -125,7 +125,7 @@ def defer_measurements(
 
     .. note::
 
-        Devices that inherit from :class:`~pennylane.QubitDevice` **must** be initialized
+        Devices that inherit from :class:`~pennylane.devices.QubitDevice` **must** be initialized
         with an additional wire for each mid-circuit measurement after which the measured
         wire is reused or reset for ``defer_measurements`` to transform the quantum tape
         correctly.

pennylane/transforms/tape_expand.py

@@ -45,7 +45,7 @@ def create_expand_fn(depth, stop_at=None, device=None, docstring=None):
             ``stop_at(obj)``, where ``obj`` is a *queueable* PennyLane object such as
             :class:`~.Operation` or :class:`~.MeasurementProcess`. It must return a
             boolean, indicating if the expansion should stop at this object.
-        device (pennylane.Device): Ensure that the expanded tape only uses native gates of the
+        device (pennylane.devices.LegacyDevice): Ensure that the expanded tape only uses native gates of the
             given device.
         docstring (str): docstring for the generated expansion function
 
@@ -331,7 +331,7 @@ def create_decomp_expand_fn(custom_decomps, dev, decomp_depth=10):
     Args:
         custom_decomps (Dict[Union(str, qml.operation.Operation), Callable]): Custom
             decompositions to be applied by the device at runtime.
-        dev (pennylane.Device): A quantum device.
+        dev (pennylane.devices.LegacyDevice): A quantum device.
         decomp_depth: The maximum depth of the expansion.
 
     Returns:
@@ -464,7 +464,7 @@ def set_decomposition(custom_decomps, dev, decomp_depth=10):
     Args:
         custom_decomps (Dict[Union(str, qml.operation.Operation), Callable]): Custom
             decompositions to be applied by the device at runtime.
-        dev (pennylane.Device): A quantum device.
+        dev (pennylane.devices.LegacyDevice): A quantum device.
         decomp_depth: The maximum depth of the expansion.
 
     **Example**

pennylane/workflow/execution.py

@@ -328,7 +328,7 @@ def execute(
 
     Args:
         tapes (Sequence[.QuantumTape]): batch of tapes to execute
-        device (pennylane.Device): Device to use to execute the batch of tapes.
+        device (pennylane.devices.LegacyDevice): Device to use to execute the batch of tapes.
             If the device does not provide a ``batch_execute`` method,
             by default the tapes will be executed in serial.
         gradient_fn (None or callable): The gradient transform function to use

pennylane/workflow/interfaces/jax_jit.py

@@ -240,7 +240,7 @@ def jax_jit_jvp_execute(tapes, execute_fn, jpc, device):
         tapes (Sequence[.QuantumTape]): batch of tapes to execute
         execute_fn (Callable[[Sequence[.QuantumTape]], ResultBatch]): a function that turns a batch of circuits into results
         jpc (JacobianProductCalculator): a class that can compute the Jacobian for the input tapes.
-        device (pennylane.Device, pennylane.devices.Device): The device used for execution. Used to determine the shapes of outputs for
+        device (pennylane.devices.LegacyDevice, pennylane.devices.Device): The device used for execution. Used to determine the shapes of outputs for
             pure callback calls.
 
     Returns:
@@ -267,7 +267,7 @@ def jax_jit_vjp_execute(tapes, execute_fn, jpc, device=None):
         execute_fn (Callable[[Sequence[.QuantumTape]], ResultBatch]): a function that turns a batch of circuits into results
         jpc (JacobianProductCalculator): a class that can compute the vector Jacobian product (VJP)
             for the input tapes.
-        device (pennylane.Device, pennylane.devices.Device): The device used for execution. Used to determine the shapes of outputs for
+        device (pennylane.devices.LegacyDevice, pennylane.devices.Device): The device used for execution. Used to determine the shapes of outputs for
             pure callback calls.
 
     Returns:

pennylane/workflow/interfaces/tensorflow_autograph.py

@@ -101,7 +101,7 @@ def execute(
 
     Args:
         tapes (Sequence[.QuantumTape]): batch of tapes to execute
-        device (pennylane.Device): Device to use to execute the batch of tapes.
+        device (pennylane.devices.LegacyDevice): Device to use to execute the batch of tapes.
             If the device does not provide a ``batch_execute`` method,
             by default the tapes will be executed in serial.
         execute_fn (callable): The execution function used to execute the tapes

pennylane/workflow/jacobian_products.py

@@ -339,11 +339,11 @@ class DeviceDerivatives(JacobianProductCalculator):
 
     Args:
 
-        device (Union[pennylane.Device, pennylane.devices.Device]): the device for execution and derivatives.
+        device (Union[pennylane.devices.LegacyDevice, pennylane.devices.Device]): the device for execution and derivatives.
             Must support first order gradients with the requested configuration.
         execution_config (pennylane.devices.ExecutionConfig): a datastructure containing the options needed to fully
            describe the execution. Only used with :class:`pennylane.devices.Device` from the new device interface.
-        gradient_kwargs (dict): a dictionary of keyword arguments for the gradients. Only used with a :class:`~.pennylane.Device`
+        gradient_kwargs (dict): a dictionary of keyword arguments for the gradients. Only used with a :class:`~.pennylane.devices.LegacyDevice`
             from the old device interface.
 
     **Examples:**

tests/devices/test_legacy_device.py

@@ -189,12 +189,6 @@ def get_device(wires=1):
         yield get_device
 
 
-def test_deprecated_access():
-    """Test that accessing via top-level is deprecated."""
-    with pytest.warns(qml.PennyLaneDeprecationWarning, match="Device will no longer be accessible"):
-        qml.Device  # pylint: disable=pointless-statement
-
-
 # pylint: disable=pointless-statement
 def test_invalid_attribute_in_devices_raises_error():
     with pytest.raises(AttributeError, match="'pennylane.devices' has no attribute 'blabla'"):

tests/devices/test_qubit_device.py

@@ -166,12 +166,6 @@ def _working_get_batch_size(tensor, expected_shape, expected_size):
     return None
 
 
-def test_deprecated_access():
-    """Test that accessing via top-level is deprecated."""
-    with pytest.warns(qml.PennyLaneDeprecationWarning, match="Device will no longer be accessible"):
-        qml.QubitDevice  # pylint: disable=pointless-statement
-
-
 def test_notimplemented_circuit_hash(mock_qubit_device):
     """Test that the circuit hash property is not implemented"""
     dev = mock_qubit_device()

tests/devices/test_qutrit_device.py

@@ -142,12 +142,6 @@ def get_qutrit_device(wires=1):
 # TODO: Add tests for expval, var after observables are added
 
 
-def test_deprecated_access():
-    """Test that accessing via top-level is deprecated."""
-    with pytest.warns(qml.PennyLaneDeprecationWarning, match="Device will no longer be accessible"):
-        qml.QutritDevice  # pylint: disable=pointless-statement
-
-
 class TestOperations:
     """Tests the logic related to operations"""
 
@@ -1196,8 +1190,8 @@ def circuit(U):
 class TestUnimplemented:
     """Tests for class methods that aren't implemented
 
-    These tests are for reaching 100% coverage of :class:`pennylane.QutritDevice`, as the
-    methods/properties being tested here have been overriden from :class:`pennylane.QubitDevice`
+    These tests are for reaching 100% coverage of :class:`pennylane.devices.QutritDevice`, as the
+    methods/properties being tested here have been overriden from :class:`pennylane.devices.QubitDevice`
     to avoid unexpected behaviour, but do not yet have working implementations.
     """
 

tests/test_qnode.py

@@ -214,7 +214,7 @@ def test_best_method_is_param_shift(self):
 
     # pylint: disable=protected-access
     @pytest.mark.xfail(
-        reason="qml.Device will always work with 'parameter-shift' and never falls back on 'finite-diff'"
+        reason="qml.device will always work with 'parameter-shift' and never falls back on 'finite-diff'"
     )
     def test_best_method_is_finite_diff(self, monkeypatch):
         """Test that the method for determining the best diff method