qiskit 2.0.2__cp39-abi3-macosx_11_0_arm64.whl → 2.1.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/visualization/dag_visualization.py

@@ -30,6 +30,9 @@ from qiskit.utils import optionals as _optionals
 from qiskit.exceptions import InvalidFileError
 from .exceptions import VisualizationError
 
+from .style import load_style
+from .dag.dagstyle import DAGStyleDict, DAGDefaultStyle
+
 
 IMAGE_TYPES = {
     "canon",
@@ -73,7 +76,12 @@ IMAGE_TYPES = {
 
 @_optionals.HAS_GRAPHVIZ.require_in_call
 @_optionals.HAS_PIL.require_in_call
-def dag_drawer(dag, scale=0.7, filename=None, style="color"):
+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.
 
@@ -84,8 +92,19 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
         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
+        style (dict or str): Style name, file name of style JSON file, or a
+            dictionary specifying the style.
+
+            * The supported style names are 'plain': B&W graph, 'color' (default):
+                (color input/output/op nodes)
+            * If given a JSON file, e.g. ``my_style.json`` or ``my_style`` (the ``.json``
+                extension may be omitted), this function attempts to load the style dictionary
+                from that location. Note, that the JSON file must completely specify the
+                visualization specifications. The file is searched for in
+                ``qiskit/visualization/circuit/styles``, the current working directory, and
+                the location specified in ``~/.qiskit/settings.conf``.
+            * If ``None`` the default style ``"color"`` is used or, if given, the default style
+                specified in ``~/.qiskit/settings.conf``.
 
     Returns:
         PIL.Image: if in Jupyter notebook and not saving to file,
@@ -99,11 +118,10 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
 
     Example:
         .. plot::
-           :include-source:
-           :nofigs:
+            :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
 
@@ -117,8 +135,16 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
                 circ.rz(0.5, q[1])
 
             dag = circuit_to_dag(circ)
-            dag_drawer(dag)
+
+            style = {
+                "inputnodecolor": "pink",
+                "outputnodecolor": "lightblue",
+                "opnodecolor": "red",
+            }
+
+            dag_drawer(dag, style=style)
     """
+
     from PIL import Image
 
     # NOTE: use type str checking to avoid potential cyclical import
@@ -130,13 +156,30 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
         for reg in list(dag.qregs.values()) + list(dag.cregs.values())
         for (idx, bit) in enumerate(reg)
     }
+
+    graph_attrs = {}
+    if isinstance(style, dict):
+        for attr in ["fontsize", "bgcolor", "dpi", "pad"]:
+            if attr in style:
+                graph_attrs[attr] = str(style[attr])
+
+    style, _ = load_style(
+        style,
+        style_dict=DAGStyleDict,
+        default_style=DAGDefaultStyle(),
+        user_config_opt="circuit_graphviz_style",
+        user_config_path_opt="circuit_graphviz_style_path",
+        raise_error_if_not_found=True,
+    )
+
     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)}
+        graph_attrs.update({"dpi": str(100 * scale)})
+
         dag_dep_circ = dagdependency_to_circuit(dag)
 
         def node_attr_func(node):
@@ -144,63 +187,64 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
                 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 = {}
+            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["label"] = (
+                nid_str + ": " + str(node.name) + " (" + str(args)[1:-1].replace("'", "") + ")"
+            )
+            if 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["label"] = (
-                    nid_str + ": " + str(node.name) + " (" + str(args)[1:-1].replace("'", "") + ")"
+                    nid_str
+                    + ": "
+                    + str(node.name)
+                    + cond_txt
+                    + str(args)[1:-1].replace("'", "")
+                    + ")"
                 )
+
+            if isinstance(style, dict):
+                n["style"] = "filled"
+
+                if "nodecolor" in style:
+                    n["fillcolor"] = style["nodecolor"]
+
+                if "fontsize" in style:
+                    n["fontsize"] = str(style["fontsize"])
+
                 if node.name == "barrier":
-                    n["style"] = "filled"
-                    n["fillcolor"] = "grey"
+                    n["fillcolor"] = style["barriercolor"]
                 elif getattr(node.op, "_directive", False):
-                    n["style"] = "filled"
-                    n["fillcolor"] = "red"
+                    n["fillcolor"] = style["directivecolor"]
                 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"
+                    n["fillcolor"] = style["conditioncolor"]
+                elif node.name == "measure":
+                    n["fillcolor"] = style["measurecolor"]
+
                 return n
             else:
                 raise VisualizationError(f"Unrecognized style {style} for the dag_drawer.")
@@ -208,55 +252,66 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
         edge_attr_func = None
 
     else:
-        graph_attrs = {"dpi": str(100 * scale)}
+        graph_attrs.update({"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 = {}
+            if isinstance(node, DAGOpNode):
+                n["label"] = node.name
+            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
+            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
+
+            if isinstance(style, dict):
+                n["style"] = "filled"
+
+                if "nodecolor" in style:
+                    n["fillcolor"] = style["nodecolor"]
+
+                if "fontsize" in style:
+                    n["fontsize"] = str(style["fontsize"])
 
-                    n["label"] = label
-                    n["color"] = "black"
-                    n["style"] = "filled"
-                    n["fillcolor"] = "green"
+                if isinstance(node, DAGInNode):
+                    if "inputnodecolor" in style:
+                        n["fillcolor"] = style["inputnodecolor"]
+                    if "inputnodefontcolor" in style:
+                        n["fontcolor"] = style["inputnodefontcolor"]
                 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"
+                    if "outputnodecolor" in style:
+                        n["fillcolor"] = style["outputnodecolor"]
+                    if "outputnodefontcolor" in style:
+                        n["fontcolor"] = style["outputnodefontcolor"]
+                if isinstance(node, DAGOpNode):
+                    if "opnodecolor" in style:
+                        n["fillcolor"] = style["opnodecolor"]
+                    if "opnodefontcolor" in style:
+                        n["fontcolor"] = style["opnodefontcolor"]
+
                 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):
@@ -264,6 +319,21 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
             else:
                 label = str(edge.name)
             e["label"] = label
+
+            if isinstance(style, dict):
+                if "edgecolor" in style:
+                    e["color"] = style["edgecolor"]
+                if "fontsize" in style:
+                    e["fontsize"] = str(style["fontsize"])
+
+                if isinstance(edge, Qubit):
+                    if "qubitedgecolor" in style:
+                        e["color"] = style["qubitedgecolor"]
+                if isinstance(edge, Clbit):
+                    if "clbitedgecolor" in style:
+                        e["color"] = style["clbitedgecolor"]
+                return e
+
             return e
 
     image_type = "png"
@@ -307,6 +377,7 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
                 text=True,
             )
             return None
+
     else:
         return graphviz_draw(
             dag._multi_graph,

qiskit/visualization/style.py

@@ -0,0 +1,223 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# 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.
+
+"""
+Generic style visualization library.
+"""
+
+import json
+import os
+from typing import Any, Union
+from warnings import warn
+from pathlib import Path
+
+from qiskit import user_config
+
+from .exceptions import VisualizationError
+
+
+class StyleDict(dict):
+    """
+    Attributes:
+        VALID_FIELDS (set): Set of valid field inputs to a function that supports a style parameter
+        ABBREVIATIONS (dict): Mapping of abbreviation:field for abbreviated inputs to VALID_FIELDS
+            (must exist in VALID FIELDS)
+        NESTED_ATTRS (set): Set of fields that are dictionaries, and need to be updated with .update
+    """
+
+    VALID_FIELDS = set()
+    ABBREVIATIONS = {}
+    NESTED_ATTRS = set()
+
+    def __setitem__(self, key: Any, value: Any) -> None:
+        # allow using field ABBREVIATIONS
+        if key in self.ABBREVIATIONS:
+            key = self.ABBREVIATIONS[key]
+
+        if key not in self.VALID_FIELDS:
+            warn(
+                f"style option ({key}) is not supported",
+                UserWarning,
+                2,
+            )
+        return super().__setitem__(key, value)
+
+    def __getitem__(self, key: Any) -> Any:
+        # allow using field ABBREVIATIONS
+        if key in self.ABBREVIATIONS:
+            key = self.ABBREVIATIONS[key]
+
+        return super().__getitem__(key)
+
+    def update(self, other):
+        # the attributes "displaycolor" and "displaytext" are dictionaries
+        # themselves, therefore we need to propagate the update down to them
+        for attr in self.NESTED_ATTRS.intersection(other.keys()):
+            if attr in self.keys():
+                self[attr].update(other[attr])
+            else:
+                self[attr] = other[attr]
+
+        super().update((key, value) for key, value in other.items() if key not in self.NESTED_ATTRS)
+
+
+class DefaultStyle:
+    """
+    Attributes:
+        DEFAULT_STYLE_NAME (str): style name for the default style
+        STYLE_PATH: file path where DEFAULT_STYLE_NAME.json is located
+    """
+
+    DEFAULT_STYLE_NAME = None
+    DEFAULT_STYLE_PATH = None
+
+    def __init__(self):
+        raise NotImplementedError()
+
+
+def load_style(
+    style: Union[dict, str, None],
+    style_dict: type[StyleDict],
+    default_style: DefaultStyle,
+    user_config_opt: str,
+    user_config_path_opt: str,
+    raise_error_if_not_found: bool = False,
+) -> tuple[StyleDict, float]:
+    """Utility function to load style from json files.
+
+    Args:
+        style: Depending on the type, this acts differently:
+
+            * If a string, it can specify a supported style name (such
+              as "iqp" or "clifford"). It can also specify the name of
+              a custom color scheme stored as JSON file. This JSON file
+              _must_ specify a complete set of colors.
+            * If a dictionary, it may specify the style name via a
+              ``{"name": "<desired style>"}`` entry. If this is not given,
+              the default style will be used. The remaining entries in the
+              dictionary can be used to override certain specs.
+              E.g. ``{"name": "iqp", "ec": "#FF0000"}`` will use the ``"iqp"``
+              color scheme but set the edgecolor to red.
+        style_dict: The class used to define the options for loading styles
+        default_style: DefaultStyle dictionary definition and documentation
+        user_config_opt: User config field in the Qiskit User Configuration File
+            used to define the style loaded
+        user_config_path_opt: User config field in the Qiskit User Configuration File
+            used to define the path to the style loaded
+        raise_error_if_not_found: When True, load_style will throw a VisualizationError
+            if the style parameter file is not found. When False, load_style will load
+            the style passed in by the default_style parameter.
+
+
+    Returns:
+        A tuple containing the style as dictionary and the default font ratio.
+    """
+
+    default = default_style.DEFAULT_STYLE_NAME
+
+    # if the style is not given, try to load the configured default (if set),
+    # or use the default style
+    config = user_config.get_config()
+    if style is None:
+        if config:
+            style = config.get(user_config_opt, default)
+        else:
+            style = default
+
+    # determine the style name which could also be inside a dictionary, like
+    # style={"name": "clifford", <other settings...>}
+    if isinstance(style, dict):
+        style_name = style.get("name", default)
+    elif isinstance(style, str):
+        if style.endswith(".json"):
+            style_name = style[:-5]
+        else:
+            style_name = style
+    else:
+        warn(
+            f'Unsupported style parameter "{style}" of type {type(style)}. '
+            "Will use the default style.",
+            UserWarning,
+            2,
+        )
+        style_name = default
+
+    if style_name in [default]:
+        current_style = default_style.style
+    else:
+        # Search for file in 'styles' dir, then config_path, and finally the current directory
+        style_name = style_name + ".json"
+        style_paths = []
+
+        default_path = default_style.DEFAULT_STYLE_PATH / style_name
+        style_paths.append(default_path)
+
+        # check configured paths, if there are any
+        if config:
+            config_path = config.get(user_config_path_opt, "")
+            if config_path:
+                for path in config_path:
+                    style_paths.append(Path(path) / style_name)
+
+        # check current directory
+        cwd_path = Path("") / style_name
+        style_paths.append(cwd_path)
+
+        for path in style_paths:
+            # expand ~ to the user directory and check if the file exists
+            exp_user = path.expanduser()
+            if os.path.isfile(exp_user):
+                try:
+                    with open(exp_user) as infile:
+                        json_style = json.load(infile)
+
+                    current_style = style_dict(json_style)
+                    break
+                except json.JSONDecodeError as err:
+                    warn(
+                        f"Could not decode JSON in file '{path}': {str(err)}. "
+                        "Will use default style.",
+                        UserWarning,
+                        2,
+                    )
+                    break
+                except (OSError, FileNotFoundError):
+                    warn(
+                        f"Error loading JSON file '{path}'. Will use default style.",
+                        UserWarning,
+                        2,
+                    )
+                    break
+        else:
+            if raise_error_if_not_found:
+                raise VisualizationError(f"Invalid style {style_name}")
+
+            warn(
+                f"Style JSON file '{style_name}' not found in any of these locations: "
+                f"{', '.join(map(str, style_paths))}. "
+                "Will use default style.",
+                UserWarning,
+                2,
+            )
+            current_style = default_style.style
+
+    # if the style is a dictionary, update the defaults with the new values
+    # this _needs_ to happen after loading by name to cover cases like
+    #   style = {"name": "bw", "edgecolor": "#FF0000"}
+    if isinstance(style, dict):
+        current_style.update(style)
+
+    # this is the default font ratio
+    # if the font- or subfont-sizes are changed, the new size is based on this ratio
+    def_font_ratio = 13 / 8
+
+    return current_style, def_font_ratio

{qiskit-2.0.2.dist-info → qiskit-2.1.0rc1.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: qiskit
-Version: 2.0.2
+Version: 2.1.0rc1
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0
 Project-URL: Homepage, https://www.ibm.com/quantum/qiskit
-Project-URL: Documentation, https://docs.quantum.ibm.com
-Project-URL: API Reference, https://docs.quantum.ibm.com/api/qiskit
+Project-URL: Documentation, https://quantum.cloud.ibm.com/docs
+Project-URL: API Reference, https://quantum.cloud.ibm.com/docs/api/qiskit
 Project-URL: Repository, https://github.com/Qiskit/qiskit
 Project-URL: Issues, https://github.com/Qiskit/qiskit/issues
-Project-URL: Changelog, https://docs.quantum.ibm.com/api/qiskit/release-notes
+Project-URL: Changelog, https://quantum.cloud.ibm.com/docs/api/qiskit/release-notes
 Keywords: qiskit,quantum circuit,quantum computing,quantum programming language,quantum,sdk
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -31,12 +31,9 @@ License-File: LICENSE.txt
 Requires-Dist: rustworkx>=0.15.0
 Requires-Dist: numpy<3,>=1.17
 Requires-Dist: scipy>=1.5
-Requires-Dist: sympy>=1.3
 Requires-Dist: dill>=0.3
-Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: stevedore>=3.0.0
 Requires-Dist: typing-extensions
-Requires-Dist: symengine<0.14,>=0.11
 Provides-Extra: qasm3-import
 Requires-Dist: qiskit-qasm3-import>=0.1.0; extra == "qasm3-import"
 Provides-Extra: visualization
@@ -45,19 +42,23 @@ Requires-Dist: pydot; extra == "visualization"
 Requires-Dist: Pillow>=4.2.1; extra == "visualization"
 Requires-Dist: pylatexenc>=1.4; extra == "visualization"
 Requires-Dist: seaborn>=0.9.0; extra == "visualization"
+Requires-Dist: sympy>=1.3; extra == "visualization"
 Provides-Extra: crosstalk-pass
 Requires-Dist: z3-solver>=4.7; extra == "crosstalk-pass"
 Provides-Extra: csp-layout-pass
 Requires-Dist: python-constraint>=1.4; extra == "csp-layout-pass"
+Provides-Extra: qpy-compat
+Requires-Dist: symengine<0.14,>=0.11; extra == "qpy-compat"
+Requires-Dist: sympy>1.3; extra == "qpy-compat"
 Provides-Extra: all
-Requires-Dist: qiskit[crosstalk-pass,csp-layout-pass,qasm3-import,visualization]; extra == "all"
+Requires-Dist: qiskit[crosstalk-pass,csp-layout-pass,qasm3-import,qpy-compat,visualization]; extra == "all"
 Dynamic: license-file
 
 # Qiskit
 
 [![License](https://img.shields.io/github/license/Qiskit/qiskit.svg?)](https://opensource.org/licenses/Apache-2.0) <!--- long-description-skip-begin -->
 [![Current Release](https://img.shields.io/github/release/Qiskit/qiskit.svg?logo=Qiskit)](https://github.com/Qiskit/qiskit/releases)
-<!-- [![Extended Support Release](https://img.shields.io/github/v/release/Qiskit/qiskit?sort=semver&filter=0.*&logo=Qiskit&label=extended%20support)](https://github.com/Qiskit/qiskit/releases?q=tag%3A0) -->
+[![Extended Support Release](https://img.shields.io/github/v/release/Qiskit/qiskit?sort=semver&filter=1.*&logo=Qiskit&label=extended%20support)](https://github.com/Qiskit/qiskit/releases?q=tag%3A1)
 [![Downloads](https://img.shields.io/pypi/dm/qiskit.svg)](https://pypi.org/project/qiskit/)
 [![Coverage Status](https://coveralls.io/repos/github/Qiskit/qiskit/badge.svg?branch=main)](https://coveralls.io/github/Qiskit/qiskit?branch=main)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/qiskit)
@@ -72,7 +73,7 @@ It also contains a transpiler that supports optimizing quantum circuits, and a q
 
 For more details on how to use Qiskit, refer to the documentation located here:
 
-<https://docs.quantum.ibm.com/>
+<https://quantum.cloud.ibm.com/docs/>
 
 
 ## Installation
@@ -85,7 +86,7 @@ pip install qiskit
 
 Pip will handle all dependencies automatically and you will always install the latest (and well-tested) version.
 
-To install from source, follow the instructions in the [documentation](https://docs.quantum.ibm.com/guides/install-qiskit-source).
+To install from source, follow the instructions in the [documentation](https://quantum.cloud.ibm.com/docs/guides/install-qiskit-source).
 
 ## Create your first quantum program in Qiskit
 
@@ -146,7 +147,7 @@ and see if you can achieve this outcome. (Spoiler alert: this is not possible!)
 Using the Qiskit-provided `qiskit.primitives.StatevectorSampler` and `qiskit.primitives.StatevectorEstimator` will not take you very far.
 The power of quantum computing cannot be simulated on classical computers and you need to use real quantum hardware to scale to larger quantum circuits.
 However, running a quantum circuit on hardware requires rewriting to the basis gates and connectivity of the quantum hardware.
-The tool that does this is the [transpiler](https://docs.quantum.ibm.com/api/qiskit/transpiler), and Qiskit includes transpiler passes for synthesis, optimization, mapping, and scheduling.
+The tool that does this is the [transpiler](https://quantum.cloud.ibm.com/docs/api/qiskit/transpiler), and Qiskit includes transpiler passes for synthesis, optimization, mapping, and scheduling.
 However, it also includes a default compiler, which works very well in most examples.
 The following code will map the example circuit to the `basis_gates = ["cz", "sx", "rz"]` and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the `coupling_map = [[0, 1], [1, 2]]`.
 
@@ -209,7 +210,7 @@ release.
 
 Additionally, as part of each release, detailed release notes are written to
 document in detail what has changed as part of a release. This includes any
-documentation on potential breaking changes on upgrade and new features. See [all release notes here](https://docs.quantum.ibm.com/api/qiskit/release-notes).
+documentation on potential breaking changes on upgrade and new features. See [all release notes here](https://quantum.cloud.ibm.com/docs/api/qiskit/release-notes).
 
 ## Acknowledgements