Expand logging configuration support in PennyLane, and also target Catalyst

doc/development/guide/logging.rst

@@ -29,8 +29,21 @@ To add logging support to components of PennyLane, we must define a module logge
 
 which will be used within the given module, and track directories,
 filenames and function names, as we have defined the appropriate types
-within the formatter configuration (see :class:`pennylane.logging.DefaultFormatter`). With the logger defined, we can selectively add to the logger by if-else statements, which compare the given module’s log-level to any log record
-message it receives. This step is not necessary, as the message will
+within the formatter configuration (see :class:`pennylane.logging.DefaultFormatter`). With the logger defined, we can selectively add to the logger via two methods: 
+
+i) using decorators on the required functions and methods in a given module:
+
+.. code:: python
+
+ # debug_logger can be used to decorate and method or free function
+ # debug_logger_init can be used to decorate class __init__ methods.
+ from pennylane.logging import debug_logger, debug_logger_init
+
+ @debug_logger
+ def my_func(arg1, arg2):
+ return arg1 + arg2
+
+ii) explicitly by if-else statements, which compare the given module’s log-level to any log record message it receives. This step is not necessary, as the message will
 only output if the level is enabled, though if an expensive function
 call is required to build the string for the log-message, it can be
 faster to perform this check:
@@ -43,10 +56,9 @@ faster to perform this check:
  arg_name_1, arg_name_2, ..., arg_name_n,
  )
 
-The above line can be added below the function/method entry point,
-and the provided arguments can be used to populate the log message. This
-allows us a way to track the inputs and calls through the stack in the
-order they are executed, as is the basis for following a trail of
+Both versions provide similar functionality, though the explicit logger call allows more custom message-formatting, such as expanding functions as string representation, filtering of data, and other useful processing for a valid record.
+
+These logging options allow us a way to track the inputs and calls through the stack in the order they are executed, as is the basis for following a trail of
 execution as needed.
 
 All debug log-statements currently added to the PennyLane execution
@@ -82,6 +94,8 @@ messages based on some criteria, we can add these to the respective
 handlers. As an example, we can go through the configuration file and
 explore the options.
 
+For ease-of-development, the function :func:`qml.logging.edit_system_config` opens an editor (if the ``EDITOR`` environment variable is set), or a viewer of the existing file configuration, which can be used to modify the existing options.
+
 Modifying the configuration options
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

doc/introduction/logging.rst

@@ -29,4 +29,7 @@ outputs to the default configured handler, which is directed to the standard out
  level = "DEBUG" # Set to TRACE for highest verbosity
  propagate = false
 
+
+Viewing the existing logging configuration file is possible by calling the :func:`pennylane.logging.edit_system_config` function which will open the file in an existing browser or editor window.
+
 For more info on the customization of the logging options, please see the logging development guide at :doc:`/development/guide/logging`, and the `Python logging documentation <https://docs.python.org/3/library/logging.html>`_.

pennylane/devices/default_qubit.py

@@ -16,7 +16,6 @@
 """
 
 import concurrent.futures
-import inspect
 import logging
 from dataclasses import replace
 from functools import partial
@@ -26,6 +25,7 @@
 import numpy as np
 
 import pennylane as qml
+from pennylane.logging import debug_logger, debug_logger_init
 from pennylane.measurements.mid_measure import MidMeasureMP
 from pennylane.ops.op_math.condition import Conditional
 from pennylane.tape import QuantumTape
@@ -419,6 +419,7 @@ def reset_prng_key(self):
  """
 
  # pylint:disable = too-many-arguments
+ @debug_logger_init
  def __init__(
  self,
  wires=None,
@@ -439,6 +440,7 @@ def __init__(
  self._rng = np.random.default_rng(seed)
  self._debugger = None
 
+ @debug_logger
  def supports_derivatives(
  self,
  execution_config: Optional[ExecutionConfig] = None,
@@ -475,6 +477,7 @@ def supports_derivatives(
  return _supports_adjoint(circuit=circuit)
  return False
 
+ @debug_logger
  def preprocess(
  self,
  execution_config: ExecutionConfig = DefaultExecutionConfig,
@@ -566,20 +569,13 @@ def _setup_execution_config(self, execution_config: ExecutionConfig) -> Executio
  updated_values["device_options"][option] = getattr(self, f"_{option}")
  return replace(execution_config, **updated_values)
 
+ @debug_logger
  def execute(
  self,
  circuits: QuantumTape_or_Batch,
  execution_config: ExecutionConfig = DefaultExecutionConfig,
  ) -> Result_or_ResultBatch:
  self.reset_prng_key()
- if logger.isEnabledFor(logging.DEBUG):
- logger.debug(
- """Entry with args=(circuits=%s) called by=%s""",
- circuits,
- "::L".join(
- str(i) for i in inspect.getouterframes(inspect.currentframe(), 2)[1][1:3]
- ),
- )
 
  max_workers = execution_config.device_options.get("max_workers", self._max_workers)
  self._state_cache = {} if execution_config.use_device_jacobian_product else None
@@ -618,6 +614,7 @@ def execute(
 
  return results
 
+ @debug_logger
  def compute_derivatives(
  self,
  circuits: QuantumTape_or_Batch,
@@ -637,6 +634,7 @@ def compute_derivatives(
 
  return res
 
+ @debug_logger
  def execute_and_compute_derivatives(
  self,
  circuits: QuantumTape_or_Batch,
@@ -659,6 +657,7 @@ def execute_and_compute_derivatives(
 
  return tuple(zip(*results))
 
+ @debug_logger
  def supports_jvp(
  self,
  execution_config: Optional[ExecutionConfig] = None,
@@ -678,6 +677,7 @@ def supports_jvp(
  """
  return self.supports_derivatives(execution_config, circuit)
 
+ @debug_logger
  def compute_jvp(
  self,
  circuits: QuantumTape_or_Batch,
@@ -697,6 +697,7 @@ def compute_jvp(
 
  return res
 
+ @debug_logger
  def execute_and_compute_jvp(
  self,
  circuits: QuantumTape_or_Batch,
@@ -724,6 +725,7 @@ def execute_and_compute_jvp(
 
  return tuple(zip(*results))
 
+ @debug_logger
  def supports_vjp(
  self,
  execution_config: Optional[ExecutionConfig] = None,
@@ -743,6 +745,7 @@ def supports_vjp(
  """
  return self.supports_derivatives(execution_config, circuit)
 
+ @debug_logger
  def compute_vjp(
  self,
  circuits: QuantumTape_or_Batch,
@@ -810,6 +813,7 @@ def _state(circuit):
 
  return res
 
+ @debug_logger
  def execute_and_compute_vjp(
  self,
  circuits: QuantumTape_or_Batch,

pennylane/devices/qubit/adjoint_jacobian.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Functions to apply adjoint jacobian differentiation"""
+import logging
 from numbers import Number
 from typing import Tuple
 
 import numpy as np
 
 import pennylane as qml
+from pennylane.logging import debug_logger
 from pennylane.operation import operation_derivative
 from pennylane.tape import QuantumTape
 
@@ -27,6 +29,9 @@
 
 # pylint: disable=protected-access, too-many-branches
 
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
 
 def _dot_product_real(bra, ket, num_wires):
  """Helper for calculating the inner product for adjoint differentiation."""
@@ -68,6 +73,7 @@ def _adjoint_jacobian_state(tape: QuantumTape):
  return tuple(jac.flatten() for jac in jacobian)
 
 
+@debug_logger
 def adjoint_jacobian(tape: QuantumTape, state=None):
  """Implements the adjoint method outlined in
  `Jones and Gacon <https://arxiv.org/abs/2009.02823>`__ to differentiate an input tape.
@@ -143,6 +149,7 @@ def adjoint_jacobian(tape: QuantumTape, state=None):
  return tuple(tuple(np.array(j_) for j_ in j) for j in jac)
 
 
+@debug_logger
 def adjoint_jvp(tape: QuantumTape, tangents: Tuple[Number], state=None):
  """The jacobian vector product used in forward mode calculation of derivatives.
 
@@ -316,6 +323,7 @@ def _get_vjp_bras(tape, cotangents, ket):
  return bras, batch_size, null_batch_indices
 
 
+@debug_logger
 def adjoint_vjp(tape: QuantumTape, cotangents: Tuple[Number], state=None):
  """The vector jacobian product used in reverse-mode differentiation.
 

pennylane/devices/qubit/simulate.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Simulate a quantum script."""
+import logging
+
 # pylint: disable=protected-access
 from functools import partial
 from typing import Optional
@@ -20,6 +22,7 @@
 from numpy.random import default_rng
 
 import pennylane as qml
+from pennylane.logging import debug_logger
 from pennylane.measurements import MidMeasureMP
 from pennylane.typing import Result
 
@@ -28,6 +31,9 @@
 from .measure import measure
 from .sampling import jax_random_split, measure_with_samples
 
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
 INTERFACE_TO_LIKE = {
  # map interfaces known by autoray to themselves
  None: None,
@@ -107,6 +113,7 @@ def _postselection_postprocess(state, is_state_batched, shots, rng=None, prng_ke
  return state, shots
 
 
+@debug_logger
 def get_final_state(circuit, debugger=None, **execution_kwargs):
  """
  Get the final state that results from executing the given quantum script.
@@ -175,6 +182,7 @@ def get_final_state(circuit, debugger=None, **execution_kwargs):
 
 
 # pylint: disable=too-many-arguments
+@debug_logger
 def measure_final_state(circuit, state, is_state_batched, **execution_kwargs) -> Result:
  """
  Perform the measurements required by the circuit on the provided state.
@@ -238,6 +246,7 @@ def measure_final_state(circuit, state, is_state_batched, **execution_kwargs) ->
  return results
 
 
+@debug_logger
 def simulate(
  circuit: qml.tape.QuantumScript,
  debugger=None,
@@ -316,6 +325,7 @@ def simulate_partial(k):
  return measure_final_state(circuit, state, is_state_batched, rng=rng, prng_key=meas_key)
 
 
+@debug_logger
 def simulate_one_shot_native_mcm(
  circuit: qml.tape.QuantumScript, debugger=None, **execution_kwargs
 ) -> Result:

pennylane/logging/__init__.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 """This module enables support for log-level messaging throughout PennyLane, following the native Python logging framework interface. Please see the :doc:`PennyLane logging development guidelines</development/guide/logging>`, and the official Python documentation for details on usage https://docs.python.org/3/library/logging.html"""
 
-from .configuration import TRACE, config_path, enable_logging
+from .configuration import TRACE, config_path, edit_system_config, enable_logging
+from .decorators import debug_logger, debug_logger_init
 from .filter import DebugOnlyFilter, LocalProcessFilter
 from .formatters.formatter import DefaultFormatter, SimpleFormatter
+from .utils import _add_logging_all