qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/visualization/dag_visualization.py

@@ -0,0 +1,318 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018, 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+# pylint: disable=invalid-name
+
+"""
+Visualization function for DAG circuit representation.
+"""
+
+import io
+import subprocess
+
+from rustworkx.visualization import graphviz_draw
+
+from qiskit.dagcircuit.dagnode import DAGOpNode, DAGInNode, DAGOutNode
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.circuit import Qubit, Clbit, ClassicalRegister
+from qiskit.circuit.classical import expr
+from qiskit.converters import dagdependency_to_circuit
+from qiskit.utils import optionals as _optionals
+from qiskit.exceptions import InvalidFileError
+from .exceptions import VisualizationError
+
+
+IMAGE_TYPES = {
+    "canon",
+    "cmap",
+    "cmapx",
+    "cmapx_np",
+    "dia",
+    "dot",
+    "fig",
+    "gd",
+    "gd2",
+    "gif",
+    "hpgl",
+    "imap",
+    "imap_np",
+    "ismap",
+    "jpe",
+    "jpeg",
+    "jpg",
+    "mif",
+    "mp",
+    "pcl",
+    "pdf",
+    "pic",
+    "plain",
+    "plain-ext",
+    "png",
+    "ps",
+    "ps2",
+    "svg",
+    "svgz",
+    "vml",
+    "vmlz",
+    "vrml",
+    "vtx",
+    "wbmp",
+    "xdor",
+    "xlib",
+}
+
+
+@_optionals.HAS_GRAPHVIZ.require_in_call
+@_optionals.HAS_PIL.require_in_call
+def dag_drawer(dag, scale=0.7, filename=None, style="color"):
+    """Plot the directed acyclic graph (dag) to represent operation dependencies
+    in a quantum circuit.
+
+    This function calls the :func:`~rustworkx.visualization.graphviz_draw` function from the
+    ``rustworkx`` package to draw the DAG.
+
+    Args:
+        dag (DAGCircuit or DAGDependency): The dag to draw.
+        scale (float): scaling factor
+        filename (str): file path to save image to (format inferred from name)
+        style (str): 'plain': B&W graph
+                     'color' (default): color input/output/op nodes
+
+    Returns:
+        PIL.Image: if in Jupyter notebook and not saving to file,
+            otherwise None.
+
+    Raises:
+        VisualizationError: when style is not recognized.
+        InvalidFileError: when filename provided is not valid
+        ValueError: If the file extension for ``filename`` is not an image
+            type supported by Graphviz.
+
+    Example:
+        .. plot::
+           :include-source:
+           :nofigs:
+
+            from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
+            from qiskit.dagcircuit import DAGCircuit
+            from qiskit.converters import circuit_to_dag
+            from qiskit.visualization import dag_drawer
+
+            q = QuantumRegister(3, 'q')
+            c = ClassicalRegister(3, 'c')
+            circ = QuantumCircuit(q, c)
+            circ.h(q[0])
+            circ.cx(q[0], q[1])
+            circ.measure(q[0], c[0])
+            with circ.if_test((c, 2)):
+                circ.rz(0.5, q[1])
+
+            dag = circuit_to_dag(circ)
+            dag_drawer(dag)
+    """
+    from PIL import Image
+
+    # NOTE: use type str checking to avoid potential cyclical import
+    # the two tradeoffs ere that it will not handle subclasses and it is
+    # slower (which doesn't matter for a visualization function)
+    type_str = str(type(dag))
+    register_bit_labels = {
+        bit: f"{reg.name}[{idx}]"
+        for reg in list(dag.qregs.values()) + list(dag.cregs.values())
+        for (idx, bit) in enumerate(reg)
+    }
+    if "DAGDependency" in type_str:
+        # pylint: disable=cyclic-import
+        from qiskit.visualization.circuit._utils import get_bit_reg_index
+
+        qubit_indices = {bit: index for index, bit in enumerate(dag.qubits)}
+        clbit_indices = {bit: index for index, bit in enumerate(dag.clbits)}
+        graph_attrs = {"dpi": str(100 * scale)}
+        dag_dep_circ = dagdependency_to_circuit(dag)
+
+        def node_attr_func(node):
+            if "DAGDependencyV2" in type_str:
+                nid_str = str(node._node_id)
+            else:
+                nid_str = str(node.node_id)
+            if style == "plain":
+                return {}
+            if style == "color":
+                n = {}
+                args = []
+                for count, arg in enumerate(node.qargs + node.cargs):
+                    if count > 4:
+                        args.append("...")
+                        break
+                    if isinstance(arg, Qubit):
+                        f_str = f"q_{qubit_indices[arg]}"
+                    elif isinstance(arg, Clbit):
+                        f_str = f"c_{clbit_indices[arg]}"
+                    else:
+                        f_str = f"{arg.index}"
+                    arg_str = register_bit_labels.get(arg, f_str)
+                    args.append(arg_str)
+
+                n["color"] = "black"
+                n["label"] = (
+                    nid_str + ": " + str(node.name) + " (" + str(args)[1:-1].replace("'", "") + ")"
+                )
+                if node.name == "barrier":
+                    n["style"] = "filled"
+                    n["fillcolor"] = "grey"
+                elif getattr(node.op, "_directive", False):
+                    n["style"] = "filled"
+                    n["fillcolor"] = "red"
+                elif getattr(node.op, "condition", None):
+                    condition = node.op.condition
+                    if isinstance(condition, expr.Expr):
+                        cond_txt = " (cond: [Expr]) ("
+                    elif isinstance(condition[0], ClassicalRegister):
+                        cond_txt = f" (cond: {condition[0].name}, {int(condition[1])}) ("
+                    else:
+                        register, bit_index, reg_index = get_bit_reg_index(
+                            dag_dep_circ, condition[0]
+                        )
+                        if register is not None:
+                            cond_txt = (
+                                f" (cond: {register.name}[{reg_index}], {int(condition[1])}) ("
+                            )
+                        else:
+                            cond_txt = f" (cond: {bit_index}, {int(condition[1])}) ("
+                    n["style"] = "filled"
+                    n["fillcolor"] = "green"
+                    n["label"] = (
+                        nid_str
+                        + ": "
+                        + str(node.name)
+                        + cond_txt
+                        + str(args)[1:-1].replace("'", "")
+                        + ")"
+                    )
+                elif node.name != "measure":  # measure is unfilled
+                    n["style"] = "filled"
+                    n["fillcolor"] = "lightblue"
+                return n
+            else:
+                raise VisualizationError(f"Unrecognized style {style} for the dag_drawer.")
+
+        edge_attr_func = None
+
+    else:
+        graph_attrs = {"dpi": str(100 * scale)}
+
+        def node_attr_func(node):
+            if style == "plain":
+                return {}
+            if style == "color":
+                n = {}
+                if isinstance(node, DAGOpNode):
+                    n["label"] = node.name
+                    n["color"] = "blue"
+                    n["style"] = "filled"
+                    n["fillcolor"] = "lightblue"
+                if isinstance(node, DAGInNode):
+                    if isinstance(node.wire, Qubit):
+                        label = register_bit_labels.get(
+                            node.wire, f"q_{dag.find_bit(node.wire).index}"
+                        )
+                    elif isinstance(node.wire, Clbit):
+                        label = register_bit_labels.get(
+                            node.wire, f"c_{dag.find_bit(node.wire).index}"
+                        )
+                    else:
+                        label = str(node.wire.name)
+
+                    n["label"] = label
+                    n["color"] = "black"
+                    n["style"] = "filled"
+                    n["fillcolor"] = "green"
+                if isinstance(node, DAGOutNode):
+                    if isinstance(node.wire, Qubit):
+                        label = register_bit_labels.get(
+                            node.wire, f"q[{dag.find_bit(node.wire).index}]"
+                        )
+                    elif isinstance(node.wire, Clbit):
+                        label = register_bit_labels.get(
+                            node.wire, f"c[{dag.find_bit(node.wire).index}]"
+                        )
+                    else:
+                        label = str(node.wire.name)
+                    n["label"] = label
+                    n["color"] = "black"
+                    n["style"] = "filled"
+                    n["fillcolor"] = "red"
+                return n
+            else:
+                raise VisualizationError(f"Invalid style {style}")
+
+        def edge_attr_func(edge):
+            e = {}
+            if isinstance(edge, Qubit):
+                label = register_bit_labels.get(edge, f"q_{dag.find_bit(edge).index}")
+            elif isinstance(edge, Clbit):
+                label = register_bit_labels.get(edge, f"c_{dag.find_bit(edge).index}")
+            else:
+                label = str(edge.name)
+            e["label"] = label
+            return e
+
+    image_type = "png"
+    if filename:
+        if "." not in filename:
+            raise InvalidFileError("Parameter 'filename' must be in format 'name.extension'")
+        image_type = filename.split(".")[-1]
+        if image_type not in IMAGE_TYPES:
+            raise ValueError(
+                "The specified value for the image_type argument, "
+                f"'{image_type}' is not a valid choice. It must be one of: "
+                f"{IMAGE_TYPES}"
+            )
+
+    if isinstance(dag, DAGCircuit):
+        dot_str = dag._to_dot(
+            graph_attrs,
+            node_attr_func,
+            edge_attr_func,
+        )
+
+        prog = "dot"
+        if not filename:
+            dot_result = subprocess.run(
+                [prog, "-T", image_type],
+                input=dot_str.encode("utf-8"),
+                capture_output=True,
+                encoding=None,
+                check=True,
+                text=False,
+            )
+            dot_bytes_image = io.BytesIO(dot_result.stdout)
+            image = Image.open(dot_bytes_image)
+            return image
+        else:
+            subprocess.run(
+                [prog, "-T", image_type, "-o", filename],
+                input=dot_str,
+                check=True,
+                encoding="utf8",
+                text=True,
+            )
+            return None
+    else:
+        return graphviz_draw(
+            dag._multi_graph,
+            node_attr_func,
+            edge_attr_func,
+            graph_attrs,
+            filename,
+            image_type,
+        )

qiskit/visualization/exceptions.py

@@ -0,0 +1,21 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Exception for errors raised by visualization module."""
+
+from qiskit.exceptions import QiskitError
+
+
+class VisualizationError(QiskitError):
+    """For visualization specific errors."""
+
+    pass