qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0__cp38-abi3-win32.whl

qiskit/user_config.py

@@ -31,9 +31,11 @@ class UserConfig:
     circuit_mpl_style = default
     circuit_mpl_style_path = ~/.qiskit:<default location>
     circuit_reverse_bits = True
+    circuit_idle_wires = False
     transpile_optimization_level = 1
     parallel = False
     num_processes = 4
+    sabre_all_threads = true
 
     """
 
@@ -62,9 +64,9 @@ class UserConfig:
             if circuit_drawer:
                 if circuit_drawer not in ["text", "mpl", "latex", "latex_source", "auto"]:
                     raise exceptions.QiskitUserConfigError(
-                        "%s is not a valid circuit drawer backend. Must be "
+                        f"{circuit_drawer} is not a valid circuit drawer backend. Must be "
                         "either 'text', 'mpl', 'latex', 'latex_source', or "
-                        "'auto'." % circuit_drawer
+                        "'auto'."
                     )
                 self.settings["circuit_drawer"] = circuit_drawer
 
@@ -95,8 +97,8 @@ class UserConfig:
             if circuit_mpl_style:
                 if not isinstance(circuit_mpl_style, str):
                     warn(
-                        "%s is not a valid mpl circuit style. Must be "
-                        "a text string. Will not load style." % circuit_mpl_style,
+                        f"{circuit_mpl_style} is not a valid mpl circuit style. Must be "
+                        "a text string. Will not load style.",
                         UserWarning,
                         2,
                     )
@@ -111,8 +113,8 @@ class UserConfig:
                 for path in cpath_list:
                     if not os.path.exists(os.path.expanduser(path)):
                         warn(
-                            "%s is not a valid circuit mpl style path."
-                            " Correct the path in ~/.qiskit/settings.conf." % path,
+                            f"{path} is not a valid circuit mpl style path."
+                            " Correct the path in ~/.qiskit/settings.conf.",
                             UserWarning,
                             2,
                         )
@@ -130,6 +132,18 @@ class UserConfig:
             if circuit_reverse_bits is not None:
                 self.settings["circuit_reverse_bits"] = circuit_reverse_bits
 
+            # Parse circuit_idle_wires
+            try:
+                circuit_idle_wires = self.config_parser.getboolean(
+                    "default", "circuit_idle_wires", fallback=None
+                )
+            except ValueError as err:
+                raise exceptions.QiskitUserConfigError(
+                    f"Value assigned to circuit_idle_wires is not valid. {str(err)}"
+                )
+            if circuit_idle_wires is not None:
+                self.settings["circuit_idle_wires"] = circuit_idle_wires
+
             # Parse transpile_optimization_level
             transpile_optimization_level = self.config_parser.getint(
                 "default", "transpile_optimization_level", fallback=-1
@@ -155,6 +169,13 @@ class UserConfig:
                     )
                 self.settings["num_processes"] = num_processes
 
+            # Parse sabre_all_threads
+            sabre_all_threads = self.config_parser.getboolean(
+                "default", "sabre_all_threads", fallback=None
+            )
+            if sabre_all_threads is not None:
+                self.settings["sabre_all_threads"] = sabre_all_threads
+
 
 def set_config(key, value, section=None, file_path=None):
     """Adds or modifies a user configuration
@@ -191,9 +212,11 @@ def set_config(key, value, section=None, file_path=None):
         "circuit_mpl_style",
         "circuit_mpl_style_path",
         "circuit_reverse_bits",
+        "circuit_idle_wires",
         "transpile_optimization_level",
         "parallel",
         "num_processes",
+        "sabre_all_threads",
     }
 
     if section in [None, "default"]:

qiskit/utils/classtools.py

@@ -31,7 +31,7 @@ class _lift_to_method:  # pylint: disable=invalid-name
     returned unchanged if so, otherwise it is turned into the default implementation for functions,
     which makes them bindable to instances.
 
-    Python-space functions and lambdas already have this behaviour, but builtins like ``print``
+    Python-space functions and lambdas already have this behavior, but builtins like ``print``
     don't; using this class allows us to do::
 
         wrap_method(MyClass, "maybe_mutates_arguments", before=print, after=print)
@@ -49,7 +49,7 @@ class _lift_to_method:  # pylint: disable=invalid-name
 
     def __init__(self, method):
         if method is self:
-            # Prevent double-initialisation if we are passed an instance of this object to lift.
+            # Prevent double-initialization if we are passed an instance of this object to lift.
             return
         self._method = method
 
@@ -118,7 +118,7 @@ class _WrappedMethod:
 
 
 def wrap_method(cls: Type, name: str, *, before: Callable = None, after: Callable = None):
-    """Wrap the functionality the instance- or class method ``cls.name`` with additional behaviour
+    """Wrap the functionality the instance- or class method ``cls.name`` with additional behavior
     ``before`` and ``after``.
 
     This mutates ``cls``, replacing the attribute ``name`` with the new functionality.  This is

qiskit/utils/deprecation.py

@@ -29,6 +29,7 @@ def deprecate_func(
     package_name: str = "qiskit",
     removal_timeline: str = "no earlier than 3 months after the release date",
     is_property: bool = False,
+    stacklevel: int = 2,
 ):
     """Decorator to indicate a function has been deprecated.
 
@@ -50,7 +51,7 @@ def deprecate_func(
         is_property: If the deprecated function is a `@property`, set this to True so that the
             generated message correctly describes it as such. (This isn't necessary for
             property setters, as their docstring is ignored by Python.)
-
+        stacklevel: Stack level passed to :func:`warnings.warn`.
     Returns:
         Callable: The decorated callable.
     """
@@ -92,7 +93,7 @@ def deprecate_func(
 
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            warnings.warn(msg, category=category, stacklevel=2)
+            warnings.warn(msg, category=category, stacklevel=stacklevel)
             return func(*args, **kwargs)
 
         add_deprecation_to_docstring(wrapper, msg, since=since, pending=pending)

qiskit/utils/lazy_tester.py

@@ -174,7 +174,7 @@ class LazyDependencyManager(abc.ABC):
 
     def require_in_instance(self, feature_or_class):
         """A class decorator that requires the dependency is available when the class is
-        initialised.  This decorator can be used even if the class does not define an ``__init__``
+        initialized.  This decorator can be used even if the class does not define an ``__init__``
         method.
 
         Args:
@@ -186,7 +186,7 @@ class LazyDependencyManager(abc.ABC):
 
         Returns:
             Callable: a class decorator that ensures that the wrapped feature is present if the
-            class is initialised.
+            class is initialized.
         """
         if isinstance(feature_or_class, str):
             feature = feature_or_class

qiskit/utils/optionals.py

@@ -79,7 +79,7 @@ External Python Libraries
 
     * - .. py:data:: HAS_IPYTHON
       - If `the IPython kernel <https://ipython.org/>`__ is available, certain additional
-        visualisations and line magics are made available.
+        visualizations and line magics are made available.
 
     * - .. py:data:: HAS_IPYWIDGETS
       - Monitoring widgets for jobs running on external backends can be provided if `ipywidgets
@@ -94,7 +94,7 @@ External Python Libraries
         interactivity features.
 
     * - .. py:data:: HAS_MATPLOTLIB
-      - Qiskit provides several visualisation tools in the :mod:`.visualization` module.
+      - Qiskit provides several visualization tools in the :mod:`.visualization` module.
         Almost all of these are built using `Matplotlib <https://matplotlib.org/>`__, which must
         be installed in order to use them.
 
@@ -116,7 +116,7 @@ External Python Libraries
         :class:`.DAGCircuit` in certain modes.
 
     * - .. py:data:: HAS_PYDOT
-      - For some graph visualisations, Qiskit uses `pydot <https://github.com/pydot/pydot>`__ as an
+      - For some graph visualizations, Qiskit uses `pydot <https://github.com/pydot/pydot>`__ as an
         interface to GraphViz (see :data:`HAS_GRAPHVIZ`).
 
     * - .. py:data:: HAS_PYGMENTS
@@ -134,7 +134,7 @@ External Python Libraries
         <https://qiskit.github.io/qiskit-qasm3-import>`__.
 
     * - .. py:data:: HAS_SEABORN
-      - Qiskit provides several visualisation tools in the :mod:`.visualization` module.  Some
+      - Qiskit provides several visualization tools in the :mod:`.visualization` module.  Some
         of these are built using `Seaborn <https://seaborn.pydata.org/>`__, which must be installed
         in order to use them.
 
@@ -179,16 +179,16 @@ External Command-Line Tools
     :widths: 25 75
 
     * - .. py:data:: HAS_GRAPHVIZ
-      - For some graph visualisations, Qiskit uses the `GraphViz <https://graphviz.org/>`__
-        visualisation tool via its ``pydot`` interface (see :data:`HAS_PYDOT`).
+      - For some graph visualizations, Qiskit uses the `GraphViz <https://graphviz.org/>`__
+        visualization tool via its ``pydot`` interface (see :data:`HAS_PYDOT`).
 
     * - .. py:data:: HAS_PDFLATEX
-      - Visualisation tools that use LaTeX in their output, such as the circuit drawers, require
+      - Visualization tools that use LaTeX in their output, such as the circuit drawers, require
         ``pdflatex`` to be available.  You will generally need to ensure that you have a working
         LaTeX installation available, and the ``qcircuit.tex`` package.
 
     * - .. py:data:: HAS_PDFTOCAIRO
-      - Visualisation tools that convert LaTeX-generated files into rasterised images use the
+      - Visualization tools that convert LaTeX-generated files into rasterized images use the
         ``pdftocairo`` tool.  This is part of the `Poppler suite of PDF tools
         <https://poppler.freedesktop.org/>`__.
 

qiskit/visualization/bloch.py

@@ -332,7 +332,7 @@ class Bloch:
             self.zlabel = ["$\\circlearrowleft$", "$\\circlearrowright$"]
             self.xlabel = ["$\\leftrightarrow$", "$\\updownarrow$"]
         else:
-            raise Exception("No such convention.")
+            raise ValueError("No such convention.")
 
     def __str__(self):
         string = ""
@@ -438,7 +438,7 @@ class Bloch:
         if isinstance(state_or_vector, (list, np.ndarray, tuple)) and len(state_or_vector) == 3:
             vec = state_or_vector
         else:
-            raise Exception("Position needs to be specified by a qubit " + "state or a 3D vector.")
+            raise TypeError("Position needs to be specified by a qubit state or a 3D vector.")
         self.annotations.append({"position": vec, "text": text, "opts": kwargs})
 
     def make_sphere(self):
@@ -630,11 +630,11 @@ class Bloch:
     def plot_vectors(self):
         """Plot vector"""
         # -X and Y data are switched for plotting purposes
-        for k in range(len(self.vectors)):
+        for k, vector in enumerate(self.vectors):
 
-            xs3d = self.vectors[k][1] * np.array([0, 1])
-            ys3d = -self.vectors[k][0] * np.array([0, 1])
-            zs3d = self.vectors[k][2] * np.array([0, 1])
+            xs3d = vector[1] * np.array([0, 1])
+            ys3d = -vector[0] * np.array([0, 1])
+            zs3d = vector[2] * np.array([0, 1])
 
             color = self.vector_color[np.mod(k, len(self.vector_color))]
 
@@ -660,15 +660,10 @@ class Bloch:
     def plot_points(self):
         """Plot points"""
         # -X and Y data are switched for plotting purposes
-        for k in range(len(self.points)):
-            num = len(self.points[k][0])
+        for k, point in enumerate(self.points):
+            num = len(point[0])
             dist = [
-                np.sqrt(
-                    self.points[k][0][j] ** 2
-                    + self.points[k][1][j] ** 2
-                    + self.points[k][2][j] ** 2
-                )
-                for j in range(num)
+                np.sqrt(point[0][j] ** 2 + point[1][j] ** 2 + point[2][j] ** 2) for j in range(num)
             ]
             if any(abs(dist - dist[0]) / dist[0] > 1e-12):
                 # combine arrays so that they can be sorted together
@@ -680,9 +675,9 @@ class Bloch:
                 indperm = np.arange(num)
             if self.point_style[k] == "s":
                 self.axes.scatter(
-                    np.real(self.points[k][1][indperm]),
-                    -np.real(self.points[k][0][indperm]),
-                    np.real(self.points[k][2][indperm]),
+                    np.real(point[1][indperm]),
+                    -np.real(point[0][indperm]),
+                    np.real(point[2][indperm]),
                     s=self.point_size[np.mod(k, len(self.point_size))],
                     alpha=1,
                     edgecolor=None,
@@ -699,9 +694,9 @@ class Bloch:
                 marker = self.point_marker[np.mod(k, len(self.point_marker))]
                 pnt_size = self.point_size[np.mod(k, len(self.point_size))]
                 self.axes.scatter(
-                    np.real(self.points[k][1][indperm]),
-                    -np.real(self.points[k][0][indperm]),
-                    np.real(self.points[k][2][indperm]),
+                    np.real(point[1][indperm]),
+                    -np.real(point[0][indperm]),
+                    np.real(point[2][indperm]),
                     s=pnt_size,
                     alpha=1,
                     edgecolor=None,
@@ -713,9 +708,9 @@ class Bloch:
             elif self.point_style[k] == "l":
                 color = self.point_color[np.mod(k, len(self.point_color))]
                 self.axes.plot(
-                    np.real(self.points[k][1]),
-                    -np.real(self.points[k][0]),
-                    np.real(self.points[k][2]),
+                    np.real(point[1]),
+                    -np.real(point[0]),
+                    np.real(point[2]),
                     alpha=0.75,
                     zdir="z",
                     color=color,

qiskit/visualization/circuit/_utils.py

@@ -14,21 +14,25 @@
 
 import re
 from collections import OrderedDict
+from warnings import warn
 
 import numpy as np
 
 from qiskit.circuit import (
+    ClassicalRegister,
     Clbit,
+    ControlFlowOp,
     ControlledGate,
     Delay,
     Gate,
     Instruction,
     Measure,
+    QuantumCircuit,
+    Qubit,
 )
+from qiskit.circuit.annotated_operation import AnnotatedOperation, InverseModifier, PowerModifier
 from qiskit.circuit.controlflow import condition_resources
 from qiskit.circuit.library import PauliEvolutionGate
-from qiskit.circuit import ClassicalRegister, QuantumCircuit, Qubit, ControlFlowOp
-from qiskit.circuit.annotated_operation import AnnotatedOperation, InverseModifier, PowerModifier
 from qiskit.circuit.tools import pi_check
 from qiskit.converters import circuit_to_dag
 from qiskit.utils import optionals as _optionals
@@ -112,7 +116,7 @@ def get_gate_ctrl_text(op, drawer, style=None, calibrations=None):
             gate_text = gate_text.replace("-", "\\mbox{-}")
         ctrl_text = f"$\\mathrm{{{ctrl_text}}}$"
 
-    # Only captitalize internally-created gate or instruction names
+    # Only capitalize internally-created gate or instruction names
     elif (
         (gate_text == op.name and op_type not in (Gate, Instruction))
         or (gate_text == base_name and base_type not in (Gate, Instruction))
@@ -370,6 +374,29 @@ def generate_latex_label(label):
     return final_str.replace(" ", "\\,")  # Put in proper spaces
 
 
+def _get_valid_justify_arg(justify):
+    """Returns a valid `justify` argument, warning if necessary."""
+    if isinstance(justify, str):
+        justify = justify.lower()
+
+    if justify is None:
+        justify = "left"
+
+    if justify not in ("left", "right", "none"):
+        # This code should be changed to an error raise, once the deprecation is complete.
+        warn(
+            f"Setting QuantumCircuit.draw()’s or circuit_drawer()'s justify argument: {justify}, to a "
+            "value other than 'left', 'right', 'none' or None (='left'). Default 'left' will be used. "
+            "Support for invalid justify arguments is deprecated as of Qiskit 1.2.0. Starting no "
+            "earlier than 3 months after the release date, invalid arguments will error.",
+            DeprecationWarning,
+            2,
+        )
+        justify = "left"
+
+    return justify
+
+
 def _get_layered_instructions(
     circuit, reverse_bits=False, justify=None, idle_wires=True, wire_order=None, wire_map=None
 ):
@@ -384,9 +411,10 @@ def _get_layered_instructions(
         reverse_bits (bool): If true the order of the bits in the registers is
             reversed.
         justify (str) : `left`, `right` or `none`. Defaults to `left`. Says how
-            the circuit should be justified.
+            the circuit should be justified. If an invalid value is provided,
+            default `left` will be used.
         idle_wires (bool): Include idle wires. Default is True.
-        wire_order (list): A list of ints that modifies the order of the bits
+        wire_order (list): A list of ints that modifies the order of the bits.
 
     Returns:
         Tuple(list,list,list): To be consumed by the visualizer directly.
@@ -394,11 +422,7 @@ def _get_layered_instructions(
     Raises:
         VisualizationError: if both reverse_bits and wire_order are entered.
     """
-    if justify:
-        justify = justify.lower()
-
-    # default to left
-    justify = justify if justify in ("right", "none") else "left"
+    justify = _get_valid_justify_arg(justify)
 
     if wire_map is not None:
         qubits = [bit for bit in wire_map if isinstance(bit, Qubit)]

qiskit/visualization/circuit/circuit_visualization.py

@@ -28,21 +28,22 @@ from __future__ import annotations
 
 import logging
 import os
+import shutil
 import subprocess
 import tempfile
-import shutil
 import typing
 from warnings import warn
 
 from qiskit import user_config
-from qiskit.utils import optionals as _optionals
 from qiskit.circuit import ControlFlowOp, Measure
+from qiskit.utils import optionals as _optionals
+
+from ..exceptions import VisualizationError
+from ..utils import _trim as trim_image
+from . import _utils
 from . import latex as _latex
-from . import text as _text
 from . import matplotlib as _matplotlib
-from . import _utils
-from ..utils import _trim as trim_image
-from ..exceptions import VisualizationError
+from . import text as _text
 
 if typing.TYPE_CHECKING:
     from typing import Any
@@ -63,7 +64,7 @@ def circuit_drawer(
     reverse_bits: bool | None = None,
     justify: str | None = None,
     vertical_compression: str | None = "medium",
-    idle_wires: bool = True,
+    idle_wires: bool | None = None,
     with_layout: bool = True,
     fold: int | None = None,
     # The type of ax is matplotlib.axes.Axes, but this is not a fixed dependency, so cannot be
@@ -115,7 +116,7 @@ def circuit_drawer(
 
         output: Select the output method to use for drawing the circuit.
             Valid choices are ``text``, ``mpl``, ``latex``, ``latex_source``.
-            By default the `text` drawer is used unless the user config file
+            By default, the ``text`` drawer is used unless the user config file
             (usually ``~/.qiskit/settings.conf``) has an alternative backend set
             as the default. For example, ``circuit_drawer = latex``. If the output
             kwarg is set, that backend will always be used over the default in
@@ -131,17 +132,19 @@ def circuit_drawer(
             alternative value set. For example, ``circuit_reverse_bits = True``.
         plot_barriers: Enable/disable drawing barriers in the output
             circuit. Defaults to ``True``.
-        justify: Options are ``left``, ``right`` or ``none``. If
-            anything else is supplied, it defaults to left justified. It refers
-            to where gates should be placed in the output circuit if there is
-            an option. ``none`` results in each gate being placed in its own
-            column.
+        justify: Options are ``"left"``, ``"right"`` or ``"none"`` (str).
+            If anything else is supplied, left justified will be used instead.
+            It refers to where gates should be placed in the output circuit if
+            there is an option. ``none`` results in each gate being placed in
+            its own column. Defaults to ``left``.
         vertical_compression: ``high``, ``medium`` or ``low``. It
             merges the lines generated by the `text` output so the drawing
             will take less vertical room.  Default is ``medium``. Only used by
             the ``text`` output, will be silently ignored otherwise.
         idle_wires: Include idle wires (wires with no circuit elements)
-            in output visualization. Default is ``True``.
+            in output visualization. Default is ``True`` unless the
+            user config file (usually ``~/.qiskit/settings.conf``) has an
+            alternative value set. For example, ``circuit_idle_wires = False``.
         with_layout: Include layout information, with labels on the
             physical layout. Default is ``True``.
         fold: Sets pagination. It can be disabled using -1. In ``text``,
@@ -200,6 +203,7 @@ def circuit_drawer(
     # Get default from config file else use text
     default_output = "text"
     default_reverse_bits = False
+    default_idle_wires = config.get("circuit_idle_wires", True)
     if config:
         default_output = config.get("circuit_drawer", "text")
         if default_output == "auto":
@@ -215,6 +219,9 @@ def circuit_drawer(
     if reverse_bits is None:
         reverse_bits = default_reverse_bits
 
+    if idle_wires is None:
+        idle_wires = default_idle_wires
+
     if wire_order is not None and reverse_bits:
         raise VisualizationError(
             "The wire_order option cannot be set when the reverse_bits option is True."
@@ -339,8 +346,8 @@ def circuit_drawer(
         )
     else:
         raise VisualizationError(
-            "Invalid output type %s selected. The only valid choices "
-            "are text, latex, latex_source, and mpl" % output
+            f"Invalid output type {output} selected. The only valid choices "
+            "are text, latex, latex_source, and mpl"
         )
     if image and interactive:
         image.show()

qiskit/visualization/circuit/latex.py

@@ -213,17 +213,22 @@ class QCircuitImage:
         self._latex.append([" "] * (self._img_depth + 1))
 
         # display the bit/register labels
-        for wire in self._wire_map:
+        for wire, index in self._wire_map.items():
             if isinstance(wire, ClassicalRegister):
                 register = wire
-                index = self._wire_map[wire]
+                wire_label = get_wire_label(
+                    "latex", register, index, layout=self._layout, cregbundle=self._cregbundle
+                )
             else:
                 register, bit_index, reg_index = get_bit_reg_index(self._circuit, wire)
-                index = bit_index if register is None else reg_index
+                wire_label = get_wire_label(
+                    "latex",
+                    register,
+                    bit_index if register is None else reg_index,
+                    layout=self._layout,
+                    cregbundle=self._cregbundle,
+                )
 
-            wire_label = get_wire_label(
-                "latex", register, index, layout=self._layout, cregbundle=self._cregbundle
-            )
             wire_label += " : "
             if self._initial_state:
                 wire_label += "\\ket{{0}}" if isinstance(wire, Qubit) else "0"
@@ -234,7 +239,7 @@ class QCircuitImage:
                 self._latex[pos][1] = "\\lstick{/_{_{" + str(register.size) + "}}} \\cw"
                 wire_label = f"\\mathrm{{{wire_label}}}"
             else:
-                pos = self._wire_map[wire]
+                pos = index
             self._latex[pos][0] = "\\nghost{" + wire_label + " & " + "\\lstick{" + wire_label
 
     def _get_image_depth(self):
@@ -410,7 +415,7 @@ class QCircuitImage:
                         cwire_list = []
 
                     if len(wire_list) == 1 and not node.cargs:
-                        self._latex[wire_list[0]][column] = "\\gate{%s}" % gate_text
+                        self._latex[wire_list[0]][column] = f"\\gate{{{gate_text}}}"
 
                     elif isinstance(op, ControlledGate):
                         num_cols_op = self._build_ctrl_gate(op, gate_text, wire_list, column)
@@ -438,20 +443,20 @@ class QCircuitImage:
             self._latex[wire_min][col] = (
                 f"\\multigate{{{wire_max - wire_min}}}{{{gate_text}}}_"
                 + "<" * (len(str(wire_ind)) + 2)
-                + "{%s}" % wire_ind
+                + f"{{{wire_ind}}}"
             )
             for wire in range(wire_min + 1, wire_max + 1):
                 if wire < cwire_start:
-                    ghost_box = "\\ghost{%s}" % gate_text
+                    ghost_box = f"\\ghost{{{gate_text}}}"
                     if wire in wire_list:
                         wire_ind = wire_list.index(wire)
                 else:
-                    ghost_box = "\\cghost{%s}" % gate_text
+                    ghost_box = f"\\cghost{{{gate_text}}}"
                     if wire in cwire_list:
                         wire_ind = cwire_list.index(wire)
                 if wire in wire_list + cwire_list:
                     self._latex[wire][col] = (
-                        ghost_box + "_" + "<" * (len(str(wire_ind)) + 2) + "{%s}" % wire_ind
+                        ghost_box + "_" + "<" * (len(str(wire_ind)) + 2) + f"{{{wire_ind}}}"
                     )
                 else:
                     self._latex[wire][col] = ghost_box
@@ -479,7 +484,7 @@ class QCircuitImage:
             elif isinstance(op.base_gate, (U1Gate, PhaseGate)):
                 num_cols_op = self._build_symmetric_gate(op, gate_text, wire_list, col)
             else:
-                self._latex[wireqargs[0]][col] = "\\gate{%s}" % gate_text
+                self._latex[wireqargs[0]][col] = f"\\gate{{{gate_text}}}"
         else:
             # Treat special cases of swap and rzz gates
             if isinstance(op.base_gate, (SwapGate, RZZGate)):
@@ -522,7 +527,7 @@ class QCircuitImage:
         )
         self._latex[wire_last][col] = "\\control \\qw"
         # Put side text to the right between bottom wire in wire_list and the one above it
-        self._latex[wire_max - 1][col + 1] = "\\dstick{\\hspace{2.0em}%s} \\qw" % gate_text
+        self._latex[wire_max - 1][col + 1] = f"\\dstick{{\\hspace{{2.0em}}{gate_text}}} \\qw"
         return 4  # num_cols for side text gates
 
     def _build_measure(self, node, col):
@@ -539,11 +544,9 @@ class QCircuitImage:
                 idx_str = str(self._circuit.find_bit(node.cargs[0]).registers[0][1])
             else:
                 wire2 = self._wire_map[node.cargs[0]]
-
-            self._latex[wire2][col] = "\\dstick{_{_{\\hspace{%sem}%s}}} \\cw \\ar @{<=} [-%s,0]" % (
-                cond_offset,
-                idx_str,
-                str(wire2 - wire1),
+            self._latex[wire2][col] = (
+                f"\\dstick{{_{{_{{\\hspace{{{cond_offset}em}}{idx_str}}}}}}} "
+                f"\\cw \\ar @{{<=}} [-{str(wire2 - wire1)},0]"
             )
         else:
             wire2 = self._wire_map[node.cargs[0]]
@@ -568,7 +571,7 @@ class QCircuitImage:
             if node.op.label is not None:
                 pos = indexes[0]
                 label = node.op.label.replace(" ", "\\,")
-                self._latex[pos][col] = "\\cds{0}{^{\\mathrm{%s}}}" % label
+                self._latex[pos][col] = f"\\cds{{0}}{{^{{\\mathrm{{{label}}}}}}}"
 
     def _add_controls(self, wire_list, ctrlqargs, ctrl_state, col):
         """Add one or more controls to a gate"""
@@ -610,21 +613,20 @@ class QCircuitImage:
             )
             gap = cwire - max(wire_list)
             control = "\\control" if op.condition[1] else "\\controlo"
-            self._latex[cwire][col] = f"{control}" + " \\cw^(%s){^{\\mathtt{%s}}} \\cwx[-%s]" % (
-                meas_offset,
-                label,
-                str(gap),
-            )
+            self._latex[cwire][
+                col
+            ] = f"{control} \\cw^({meas_offset}){{^{{\\mathtt{{{label}}}}}}} \\cwx[-{str(gap)}]"
+
         # If condition is a register and cregbundle is false
         else:
             # First sort the val_bits in the order of the register bits in the circuit
             cond_wires = []
             cond_bits = []
-            for wire in self._wire_map:
+            for wire, index in self._wire_map.items():
                 reg, _, reg_index = get_bit_reg_index(self._circuit, wire)
                 if reg == cond_reg:
                     cond_bits.append(reg_index)
-                    cond_wires.append(self._wire_map[wire])
+                    cond_wires.append(index)
 
             gap = cond_wires[0] - max(wire_list)
             prev_wire = cond_wires[0]